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

Commit acededbc authored by Roshan Pius's avatar Roshan Pius
Browse files

wifi(implementation): Dual interface support 

Add support for concurrent interfaces in the WifiLegacyHal class:
a) Removed the hardcoded "wlan0" interface handle in WifiLegacyHal.
b) Modified all the interface specific functions to accept the |iface_name|
argument on which the operation needs to be performed.

Each IWifiIface object will hold the name of the underlying network
interface (wlan0, wlan1 or p2p0) which it is representing.
All IWifiChip operations which needs an iface name will continue to use
the default "wlan0".

Bug: 65671875
Test: Device boots up and connects to wifi networks.
Test: Will send for regression tests.
Change-Id: I9bd9c2a9ba33ac1ea5677fc5d7c261d8eac08e1d
parent 9377a0d2

wifi/1.2/default/wifi_ap_iface.cpp

+2 −2
Original line number Diff line number Diff line
@@ -85,7 +85,7 @@ std::pair<WifiStatus, IfaceType> WifiApIface::getTypeInternal() { 
WifiStatus WifiApIface::setCountryCodeInternal(

    const std::array<int8_t, 2>& code) {

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->setCountryCode(code);

      legacy_hal_.lock()->setCountryCode(ifname_, code);

  return createWifiStatusFromLegacyError(legacy_status);

}
@@ -96,7 +96,7 @@ WifiApIface::getValidFrequenciesForBandInternal(WifiBand band) { 
  std::vector<uint32_t> valid_frequencies;

  std::tie(legacy_status, valid_frequencies) =

      legacy_hal_.lock()->getValidFrequenciesForBand(

          hidl_struct_util::convertHidlWifiBandToLegacy(band));

          ifname_, hidl_struct_util::convertHidlWifiBandToLegacy(band));

  return {createWifiStatusFromLegacyError(legacy_status), valid_frequencies};

}

}  // namespace implementation

wifi/1.2/default/wifi_chip.cpp

+23 −15
Original line number Diff line number Diff line
@@ -412,12 +412,12 @@ std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal() { 
  uint32_t legacy_feature_set;

  uint32_t legacy_logger_feature_set;

  std::tie(legacy_status, legacy_feature_set) =

      legacy_hal_.lock()->getSupportedFeatureSet();

      legacy_hal_.lock()->getSupportedFeatureSet(getWlan0IfaceName());

  if (legacy_status != legacy_hal::WIFI_SUCCESS) {

    return {createWifiStatusFromLegacyError(legacy_status), 0};

  }

  std::tie(legacy_status, legacy_logger_feature_set) =

      legacy_hal_.lock()->getLoggerSupportedFeatureSet();

      legacy_hal_.lock()->getLoggerSupportedFeatureSet(getWlan0IfaceName());

  if (legacy_status != legacy_hal::WIFI_SUCCESS) {

    return {createWifiStatusFromLegacyError(legacy_status), 0};

  }
@@ -503,7 +503,8 @@ WifiChip::requestChipDebugInfoInternal() { 
  IWifiChip::ChipDebugInfo result;

  legacy_hal::wifi_error legacy_status;

  std::string driver_desc;

  std::tie(legacy_status, driver_desc) = legacy_hal_.lock()->getDriverVersion();

  std::tie(legacy_status, driver_desc) =

      legacy_hal_.lock()->getDriverVersion(getWlan0IfaceName());

  if (legacy_status != legacy_hal::WIFI_SUCCESS) {

    LOG(ERROR) << "Failed to get driver version: "

               << legacyErrorToString(legacy_status);
@@ -515,7 +516,7 @@ WifiChip::requestChipDebugInfoInternal() { 


  std::string firmware_desc;

  std::tie(legacy_status, firmware_desc) =

      legacy_hal_.lock()->getFirmwareVersion();

      legacy_hal_.lock()->getFirmwareVersion(getWlan0IfaceName());

  if (legacy_status != legacy_hal::WIFI_SUCCESS) {

    LOG(ERROR) << "Failed to get firmware version: "

               << legacyErrorToString(legacy_status);
@@ -533,7 +534,7 @@ WifiChip::requestDriverDebugDumpInternal() { 
  legacy_hal::wifi_error legacy_status;

  std::vector<uint8_t> driver_dump;

  std::tie(legacy_status, driver_dump) =

      legacy_hal_.lock()->requestDriverMemoryDump();

      legacy_hal_.lock()->requestDriverMemoryDump(getWlan0IfaceName());

  if (legacy_status != legacy_hal::WIFI_SUCCESS) {

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

               << legacyErrorToString(legacy_status);
@@ -548,7 +549,7 @@ WifiChip::requestFirmwareDebugDumpInternal() { 
  legacy_hal::wifi_error legacy_status;

  std::vector<uint8_t> firmware_dump;

  std::tie(legacy_status, firmware_dump) =

      legacy_hal_.lock()->requestFirmwareMemoryDump();

      legacy_hal_.lock()->requestFirmwareMemoryDump(getWlan0IfaceName());

  if (legacy_status != legacy_hal::WIFI_SUCCESS) {

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

               << legacyErrorToString(legacy_status);
@@ -751,7 +752,7 @@ WifiChip::getDebugRingBuffersStatusInternal() { 
  std::vector<legacy_hal::wifi_ring_buffer_status>

      legacy_ring_buffer_status_vec;

  std::tie(legacy_status, legacy_ring_buffer_status_vec) =

      legacy_hal_.lock()->getRingBuffersStatus();

      legacy_hal_.lock()->getRingBuffersStatus(getWlan0IfaceName());

  if (legacy_status != legacy_hal::WIFI_SUCCESS) {

    return {createWifiStatusFromLegacyError(legacy_status), {}};

  }
@@ -775,6 +776,7 @@ WifiStatus WifiChip::startLoggingToDebugRingBufferInternal( 
  }

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->startRingBufferLogging(

          getWlan0IfaceName(),

          ring_name,

          static_cast<

              std::underlying_type<WifiDebugRingBufferVerboseLevel>::type>(
@@ -791,13 +793,14 @@ WifiStatus WifiChip::forceDumpToDebugRingBufferInternal( 
    return status;

  }

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->getRingBufferData(ring_name);

      legacy_hal_.lock()->getRingBufferData(getWlan0IfaceName(), ring_name);

  return createWifiStatusFromLegacyError(legacy_status);

}



WifiStatus WifiChip::stopLoggingToDebugRingBufferInternal() {

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->deregisterRingBufferCallbackHandler();

      legacy_hal_.lock()->deregisterRingBufferCallbackHandler(

          getWlan0IfaceName());

  return createWifiStatusFromLegacyError(legacy_status);

}
@@ -806,7 +809,7 @@ WifiChip::getDebugHostWakeReasonStatsInternal() { 
  legacy_hal::wifi_error legacy_status;

  legacy_hal::WakeReasonStats legacy_stats;

  std::tie(legacy_status, legacy_stats) =

      legacy_hal_.lock()->getWakeReasonStats();

      legacy_hal_.lock()->getWakeReasonStats(getWlan0IfaceName());

  if (legacy_status != legacy_hal::WIFI_SUCCESS) {

    return {createWifiStatusFromLegacyError(legacy_status), {}};

  }
@@ -835,22 +838,27 @@ WifiStatus WifiChip::enableDebugErrorAlertsInternal(bool enable) { 
        }

      }

    };

    legacy_status = legacy_hal_.lock()->registerErrorAlertCallbackHandler(

        on_alert_callback);

    legacy_status =

        legacy_hal_.lock()->registerErrorAlertCallbackHandler(

            getWlan0IfaceName(), on_alert_callback);

  } else {

    legacy_status = legacy_hal_.lock()->deregisterErrorAlertCallbackHandler();

    legacy_status =

        legacy_hal_.lock()->deregisterErrorAlertCallbackHandler(

            getWlan0IfaceName());

  }

  return createWifiStatusFromLegacyError(legacy_status);

}



WifiStatus WifiChip::selectTxPowerScenarioInternal(TxPowerScenario scenario) {

  auto legacy_status = legacy_hal_.lock()->selectTxPowerScenario(

      getWlan0IfaceName(),

      hidl_struct_util::convertHidlTxPowerScenarioToLegacy(scenario));

  return createWifiStatusFromLegacyError(legacy_status);

}



WifiStatus WifiChip::resetTxPowerScenarioInternal() {

  auto legacy_status = legacy_hal_.lock()->resetTxPowerScenario();

  auto legacy_status =

      legacy_hal_.lock()->resetTxPowerScenario(getWlan0IfaceName());

  return createWifiStatusFromLegacyError(legacy_status);

}
@@ -913,7 +921,7 @@ WifiStatus WifiChip::registerDebugRingBufferCallback() { 
  };

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->registerRingBufferCallbackHandler(

          on_ring_buffer_data_callback);

          getWlan0IfaceName(), on_ring_buffer_data_callback);



  if (legacy_status == legacy_hal::WIFI_SUCCESS) {

    debug_ring_buffer_cb_registered_ = true;

wifi/1.2/default/wifi_legacy_hal.cpp

+224 −160

File changed.

Preview size limit exceeded, changes collapsed.

wifi/1.2/default/wifi_legacy_hal.h

+142 −83
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#define WIFI_LEGACY_HAL_H_



#include <functional>

#include <map>

#include <thread>

#include <vector>

#include <condition_variable>
@@ -150,16 +151,24 @@ class WifiLegacyHal { 
  wifi_error stop(std::unique_lock<std::recursive_mutex>* lock,

                  const std::function<void()>& on_complete_callback);

  // 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<uint8_t>> requestDriverMemoryDump();

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

  std::pair<wifi_error, uint32_t> getSupportedFeatureSet();

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

      const std::string& iface_name);

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

      const std::string& iface_name);

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

      const std::string& iface_name);

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

      const std::string& iface_name);

  std::pair<wifi_error, uint32_t> getSupportedFeatureSet(

      const std::string& iface_name);

  // APF functions.

  std::pair<wifi_error, PacketFilterCapabilities> getPacketFilterCapabilities();

  wifi_error setPacketFilter(const std::vector<uint8_t>& program);

  std::pair<wifi_error, PacketFilterCapabilities> getPacketFilterCapabilities(

      const std::string& iface_name);

  wifi_error setPacketFilter(

      const std::string& iface_name, const std::vector<uint8_t>& program);

  // Gscan functions.

  std::pair<wifi_error, wifi_gscan_capabilities> getGscanCapabilities();

  std::pair<wifi_error, wifi_gscan_capabilities> getGscanCapabilities(

      const std::string& iface_name);

  // These API's provides a simplified interface over the legacy Gscan API's:

  // a) All scan events from the legacy HAL API other than the

  //    |WIFI_SCAN_FAILED| are treated as notification of results.
@@ -171,124 +180,174 @@ class WifiLegacyHal { 
  // c) Full scan result event triggers the externally provided

  //    |on_full_result_user_callback|.

  wifi_error startGscan(

      const std::string& iface_name,

      wifi_request_id id,

      const wifi_scan_cmd_params& params,

      const std::function<void(wifi_request_id)>& on_failure_callback,

      const on_gscan_results_callback& on_results_callback,

      const on_gscan_full_result_callback& on_full_result_callback);

  wifi_error stopGscan(wifi_request_id id);

  wifi_error stopGscan(const std::string& iface_name, wifi_request_id id);

  std::pair<wifi_error, std::vector<uint32_t>> getValidFrequenciesForBand(

      wifi_band band);

  wifi_error setDfsFlag(bool dfs_on);

      const std::string& iface_name, wifi_band band);

  wifi_error setDfsFlag(const std::string& iface_name, bool dfs_on);

  // Link layer stats functions.

  wifi_error enableLinkLayerStats(bool debug);

  wifi_error disableLinkLayerStats();

  std::pair<wifi_error, LinkLayerStats> getLinkLayerStats();

  wifi_error enableLinkLayerStats(const std::string& iface_name, bool debug);

  wifi_error disableLinkLayerStats(const std::string& iface_name);

  std::pair<wifi_error, LinkLayerStats> getLinkLayerStats(

      const std::string& iface_name);

  // RSSI monitor functions.

  wifi_error startRssiMonitoring(wifi_request_id id,

                                 int8_t max_rssi,

                                 int8_t min_rssi,

                                 const on_rssi_threshold_breached_callback&

  wifi_error startRssiMonitoring(

      const std::string& iface_name, wifi_request_id id, int8_t max_rssi,

      int8_t min_rssi, const on_rssi_threshold_breached_callback&

          on_threshold_breached_callback);

  wifi_error stopRssiMonitoring(wifi_request_id id);

  std::pair<wifi_error, wifi_roaming_capabilities> getRoamingCapabilities();

  wifi_error configureRoaming(const wifi_roaming_config& config);

  wifi_error enableFirmwareRoaming(fw_roaming_state_t state);

  wifi_error configureNdOffload(bool enable);

  wifi_error stopRssiMonitoring(

      const std::string& iface_name, wifi_request_id id);

  std::pair<wifi_error, wifi_roaming_capabilities> getRoamingCapabilities(

      const std::string& iface_name);

  wifi_error configureRoaming(

      const std::string& iface_name, const wifi_roaming_config& config);

  wifi_error enableFirmwareRoaming(

      const std::string& iface_name, fw_roaming_state_t state);

  wifi_error configureNdOffload(const std::string& iface_name, bool enable);

  wifi_error startSendingOffloadedPacket(

      const std::string& iface_name,

      uint32_t cmd_id,

      const std::vector<uint8_t>& ip_packet_data,

      const std::array<uint8_t, 6>& src_address,

      const std::array<uint8_t, 6>& dst_address,

      uint32_t period_in_ms);

  wifi_error stopSendingOffloadedPacket(uint32_t cmd_id);

  wifi_error setScanningMacOui(const std::array<uint8_t, 3>& oui);

  wifi_error selectTxPowerScenario(wifi_power_scenario scenario);

  wifi_error resetTxPowerScenario();

  wifi_error stopSendingOffloadedPacket(

      const std::string& iface_name, uint32_t cmd_id);

  wifi_error setScanningMacOui(

      const std::string& iface_name, const std::array<uint8_t, 3>& oui);

  wifi_error selectTxPowerScenario(

      const std::string& iface_name, wifi_power_scenario scenario);

  wifi_error resetTxPowerScenario(const std::string& iface_name);

  // Logger/debug functions.

  std::pair<wifi_error, uint32_t> getLoggerSupportedFeatureSet();

  wifi_error startPktFateMonitoring();

  std::pair<wifi_error, std::vector<wifi_tx_report>> getTxPktFates();

  std::pair<wifi_error, std::vector<wifi_rx_report>> getRxPktFates();

  std::pair<wifi_error, WakeReasonStats> getWakeReasonStats();

  std::pair<wifi_error, uint32_t> getLoggerSupportedFeatureSet(

      const std::string& iface_name);

  wifi_error startPktFateMonitoring(const std::string& iface_name);

  std::pair<wifi_error, std::vector<wifi_tx_report>> getTxPktFates(

      const std::string& iface_name);

  std::pair<wifi_error, std::vector<wifi_rx_report>> getRxPktFates(

      const std::string& iface_name);

  std::pair<wifi_error, WakeReasonStats> getWakeReasonStats(

      const std::string& iface_name);

  wifi_error registerRingBufferCallbackHandler(

      const std::string& iface_name,

      const on_ring_buffer_data_callback& on_data_callback);

  wifi_error deregisterRingBufferCallbackHandler();

  wifi_error deregisterRingBufferCallbackHandler(const std::string& iface_name);

  std::pair<wifi_error, std::vector<wifi_ring_buffer_status>>

  getRingBuffersStatus();

  wifi_error startRingBufferLogging(const std::string& ring_name,

                                    uint32_t verbose_level,

                                    uint32_t max_interval_sec,

  getRingBuffersStatus(const std::string& iface_name);

  wifi_error startRingBufferLogging(

      const std::string& iface_name, const std::string& ring_name,

      uint32_t verbose_level, uint32_t max_interval_sec,

      uint32_t min_data_size);

  wifi_error getRingBufferData(const std::string& ring_name);

  wifi_error getRingBufferData(

      const std::string& iface_name, const std::string& ring_name);

  wifi_error registerErrorAlertCallbackHandler(

      const std::string& iface_name,

      const on_error_alert_callback& on_alert_callback);

  wifi_error deregisterErrorAlertCallbackHandler();

  wifi_error deregisterErrorAlertCallbackHandler(const std::string& iface_name);

  // RTT functions.

  wifi_error startRttRangeRequest(

      const std::string& iface_name,

      wifi_request_id id,

      const std::vector<wifi_rtt_config>& rtt_configs,

      const on_rtt_results_callback& on_results_callback);

  wifi_error cancelRttRangeRequest(

      wifi_request_id id, const std::vector<std::array<uint8_t, 6>>& mac_addrs);

  std::pair<wifi_error, wifi_rtt_capabilities> getRttCapabilities();

  std::pair<wifi_error, wifi_rtt_responder> getRttResponderInfo();

  wifi_error enableRttResponder(wifi_request_id id,

                                const wifi_channel_info& channel_hint,

                                uint32_t max_duration_secs,

      const std::string& iface_name, wifi_request_id id,

      const std::vector<std::array<uint8_t, 6>>& mac_addrs);

  std::pair<wifi_error, wifi_rtt_capabilities> getRttCapabilities(

      const std::string& iface_name);

  std::pair<wifi_error, wifi_rtt_responder> getRttResponderInfo(

      const std::string& iface_name);

  wifi_error enableRttResponder(

      const std::string& iface_name, wifi_request_id id,

      const wifi_channel_info& channel_hint, uint32_t max_duration_secs,

      const wifi_rtt_responder& info);

  wifi_error disableRttResponder(wifi_request_id id);

  wifi_error setRttLci(wifi_request_id id, const wifi_lci_information& info);

  wifi_error setRttLcr(wifi_request_id id, const wifi_lcr_information& info);

  wifi_error disableRttResponder(

      const std::string& iface_name, wifi_request_id id);

  wifi_error setRttLci(

      const std::string& iface_name, wifi_request_id id,

      const wifi_lci_information& info);

  wifi_error setRttLcr(

      const std::string& iface_name, wifi_request_id id,

      const wifi_lcr_information& info);

  // NAN functions.

  wifi_error nanRegisterCallbackHandlers(const NanCallbackHandlers& callbacks);

  wifi_error nanEnableRequest(transaction_id id, const NanEnableRequest& msg);

  wifi_error nanDisableRequest(transaction_id id);

  wifi_error nanPublishRequest(transaction_id id, const NanPublishRequest& msg);

  wifi_error nanPublishCancelRequest(transaction_id id,

  wifi_error nanRegisterCallbackHandlers(

      const std::string& iface_name, const NanCallbackHandlers& callbacks);

  wifi_error nanEnableRequest(

      const std::string& iface_name, transaction_id id,

      const NanEnableRequest& msg);

  wifi_error nanDisableRequest(

      const std::string& iface_name, transaction_id id);

  wifi_error nanPublishRequest(

      const std::string& iface_name, transaction_id id,

      const NanPublishRequest& msg);

  wifi_error nanPublishCancelRequest(

      const std::string& iface_name, transaction_id id,

      const NanPublishCancelRequest& msg);

  wifi_error nanSubscribeRequest(transaction_id id,

  wifi_error nanSubscribeRequest(

      const std::string& iface_name, transaction_id id,

      const NanSubscribeRequest& msg);

  wifi_error nanSubscribeCancelRequest(transaction_id id,

  wifi_error nanSubscribeCancelRequest(

      const std::string& iface_name, transaction_id id,

      const NanSubscribeCancelRequest& msg);

  wifi_error nanTransmitFollowupRequest(transaction_id id,

  wifi_error nanTransmitFollowupRequest(

      const std::string& iface_name, transaction_id id,

      const NanTransmitFollowupRequest& msg);

  wifi_error nanStatsRequest(transaction_id id, const NanStatsRequest& msg);

  wifi_error nanConfigRequest(transaction_id id, const NanConfigRequest& msg);

  wifi_error nanTcaRequest(transaction_id id, const NanTCARequest& msg);

  wifi_error nanBeaconSdfPayloadRequest(transaction_id id,

  wifi_error nanStatsRequest(

      const std::string& iface_name, transaction_id id,

      const NanStatsRequest& msg);

  wifi_error nanConfigRequest(

      const std::string& iface_name, transaction_id id,

      const NanConfigRequest& msg);

  wifi_error nanTcaRequest(

      const std::string& iface_name, transaction_id id,

      const NanTCARequest& msg);

  wifi_error nanBeaconSdfPayloadRequest(

      const std::string& iface_name, transaction_id id,

      const NanBeaconSdfPayloadRequest& msg);

  std::pair<wifi_error, NanVersion> nanGetVersion();

  wifi_error nanGetCapabilities(transaction_id id);

  wifi_error nanDataInterfaceCreate(transaction_id id,

                                    const std::string& iface_name);

  wifi_error nanDataInterfaceDelete(transaction_id id,

                                    const std::string& iface_name);

  wifi_error nanDataRequestInitiator(transaction_id id,

  wifi_error nanGetCapabilities(

      const std::string& iface_name, transaction_id id);

  wifi_error nanDataInterfaceCreate(

      const std::string& iface_name, transaction_id id,

      const std::string& data_iface_name);

  wifi_error nanDataInterfaceDelete(

      const std::string& iface_name, transaction_id id,

      const std::string& data_iface_name);

  wifi_error nanDataRequestInitiator(

      const std::string& iface_name, transaction_id id,

      const NanDataPathInitiatorRequest& msg);

  wifi_error nanDataIndicationResponse(

      transaction_id id, const NanDataPathIndicationResponse& msg);

  wifi_error nanDataEnd(transaction_id id, uint32_t ndpInstanceId);

      const std::string& iface_name, transaction_id id,

      const NanDataPathIndicationResponse& msg);

  wifi_error nanDataEnd(

      const std::string& iface_name, transaction_id id, uint32_t ndpInstanceId);

  // AP functions.

  wifi_error setCountryCode(std::array<int8_t, 2> code);

  wifi_error setCountryCode(

      const std::string& iface_name, std::array<int8_t, 2> code);



 private:

  // Retrieve the interface handle to be used for the "wlan" interface.

  wifi_error retrieveWlanInterfaceHandle();

  // Retrieve interface handles for all the available interfaces.

  wifi_error retrieveIfaceHandles();

  wifi_interface_handle getIfaceHandle(const std::string& iface_name);

  // Run the legacy HAL event loop thread.

  void runEventLoop();

  // Retrieve the cached gscan results to pass the results back to the external

  // callbacks.

  std::pair<wifi_error, std::vector<wifi_cached_scan_results>>

  getGscanCachedResults();

  getGscanCachedResults(const std::string& iface_name);

  void invalidate();



  // Global function table of legacy HAL.

  wifi_hal_fn global_func_table_;

  // Opaque handle to be used for all global operations.

  wifi_handle global_handle_;

  // Opaque handle to be used for all wlan0 interface specific operations.

  wifi_interface_handle wlan_interface_handle_;

  // Map of interface name to handle that is to be used for all interface specific operations.

  std::map<std::string, wifi_interface_handle> iface_name_to_handle_;

  // Flag to indicate if we have initiated the cleanup of legacy HAL.

  std::atomic<bool> awaiting_event_loop_termination_;

  std::condition_variable_any stop_wait_cv_;

wifi/1.2/default/wifi_nan_iface.cpp

+30 −23
Original line number Diff line number Diff line
@@ -412,7 +412,8 @@ WifiNanIface::WifiNanIface( 
  };



  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->nanRegisterCallbackHandlers(callback_handlers);

      legacy_hal_.lock()->nanRegisterCallbackHandlers(

          ifname_, callback_handlers);

  if (legacy_status != legacy_hal::WIFI_SUCCESS) {

    LOG(ERROR) << "Failed to register nan callbacks. Invalidating object";

    invalidate();
@@ -421,9 +422,9 @@ WifiNanIface::WifiNanIface( 


void WifiNanIface::invalidate() {

  // send commands to HAL to actually disable and destroy interfaces

  legacy_hal_.lock()->nanDisableRequest(0xFFFF);

  legacy_hal_.lock()->nanDataInterfaceDelete(0xFFFE, "aware_data0");

  legacy_hal_.lock()->nanDataInterfaceDelete(0xFFFD, "aware_data1");

  legacy_hal_.lock()->nanDisableRequest(ifname_, 0xFFFF);

  legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, 0xFFFE, "aware_data0");

  legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, 0xFFFD, "aware_data1");



  legacy_hal_.reset();

  event_cb_handler_.invalidate();
@@ -637,7 +638,7 @@ WifiStatus WifiNanIface::registerEventCallbackInternal( 


WifiStatus WifiNanIface::getCapabilitiesRequestInternal(uint16_t cmd_id) {

  legacy_hal::wifi_error legacy_status =

        legacy_hal_.lock()->nanGetCapabilities(cmd_id);

        legacy_hal_.lock()->nanGetCapabilities(ifname_, cmd_id);

  return createWifiStatusFromLegacyError(legacy_status);

}
@@ -648,7 +649,7 @@ WifiStatus WifiNanIface::enableRequestInternal(uint16_t cmd_id, 
    return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);

  }

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->nanEnableRequest(cmd_id, legacy_msg);

      legacy_hal_.lock()->nanEnableRequest(ifname_, cmd_id, legacy_msg);

  return createWifiStatusFromLegacyError(legacy_status);

}
@@ -660,25 +661,25 @@ WifiStatus WifiNanIface::configRequestInternal( 
    return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);

  }

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->nanConfigRequest(cmd_id, legacy_msg);

      legacy_hal_.lock()->nanConfigRequest(ifname_, cmd_id, legacy_msg);

  return createWifiStatusFromLegacyError(legacy_status);

}



WifiStatus WifiNanIface::disableRequestInternal(uint16_t cmd_id) {

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->nanDisableRequest(cmd_id);

      legacy_hal_.lock()->nanDisableRequest(ifname_, cmd_id);

  return createWifiStatusFromLegacyError(legacy_status);

}



WifiStatus WifiNanIface::startPublishRequestInternal(uint16_t cmd_id,

                                                     const NanPublishRequest& msg) {

WifiStatus WifiNanIface::startPublishRequestInternal(

    uint16_t cmd_id, const NanPublishRequest& msg) {

  legacy_hal::NanPublishRequest legacy_msg;

  if (!hidl_struct_util::convertHidlNanPublishRequestToLegacy(msg,

                                                              &legacy_msg)) {

    return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);

  }

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->nanPublishRequest(cmd_id, legacy_msg);

      legacy_hal_.lock()->nanPublishRequest(ifname_, cmd_id, legacy_msg);

  return createWifiStatusFromLegacyError(legacy_status);

}
@@ -687,7 +688,7 @@ WifiStatus WifiNanIface::stopPublishRequestInternal( 
  legacy_hal::NanPublishCancelRequest legacy_msg;

  legacy_msg.publish_id = sessionId;

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->nanPublishCancelRequest(cmd_id, legacy_msg);

      legacy_hal_.lock()->nanPublishCancelRequest(ifname_, cmd_id, legacy_msg);

  return createWifiStatusFromLegacyError(legacy_status);

}
@@ -699,7 +700,7 @@ WifiStatus WifiNanIface::startSubscribeRequestInternal( 
    return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);

  }

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->nanSubscribeRequest(cmd_id, legacy_msg);

      legacy_hal_.lock()->nanSubscribeRequest(ifname_, cmd_id, legacy_msg);

  return createWifiStatusFromLegacyError(legacy_status);

}
@@ -708,57 +709,63 @@ WifiStatus WifiNanIface::stopSubscribeRequestInternal( 
  legacy_hal::NanSubscribeCancelRequest legacy_msg;

  legacy_msg.subscribe_id = sessionId;

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->nanSubscribeCancelRequest(cmd_id, legacy_msg);

      legacy_hal_.lock()->nanSubscribeCancelRequest(

          ifname_, cmd_id, legacy_msg);

  return createWifiStatusFromLegacyError(legacy_status);

}



WifiStatus WifiNanIface::transmitFollowupRequestInternal(

    uint16_t cmd_id, const NanTransmitFollowupRequest& msg) {

  legacy_hal::NanTransmitFollowupRequest legacy_msg;

  if (!hidl_struct_util::convertHidlNanTransmitFollowupRequestToLegacy(msg, &legacy_msg)) {

  if (!hidl_struct_util::convertHidlNanTransmitFollowupRequestToLegacy(

      msg, &legacy_msg)) {

    return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);

  }

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->nanTransmitFollowupRequest(cmd_id, legacy_msg);

      legacy_hal_.lock()->nanTransmitFollowupRequest(

          ifname_, cmd_id, legacy_msg);

  return createWifiStatusFromLegacyError(legacy_status);

}



WifiStatus WifiNanIface::createDataInterfaceRequestInternal(

    uint16_t cmd_id, const std::string& iface_name) {

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->nanDataInterfaceCreate(cmd_id, iface_name);

      legacy_hal_.lock()->nanDataInterfaceCreate(ifname_, cmd_id, iface_name);

  return createWifiStatusFromLegacyError(legacy_status);

}

WifiStatus WifiNanIface::deleteDataInterfaceRequestInternal(

    uint16_t cmd_id, const std::string& iface_name) {

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->nanDataInterfaceDelete(cmd_id, iface_name);

      legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, cmd_id, iface_name);

  return createWifiStatusFromLegacyError(legacy_status);

}

WifiStatus WifiNanIface::initiateDataPathRequestInternal(

    uint16_t cmd_id, const NanInitiateDataPathRequest& msg) {

  legacy_hal::NanDataPathInitiatorRequest legacy_msg;

  if (!hidl_struct_util::convertHidlNanDataPathInitiatorRequestToLegacy(msg, &legacy_msg)) {

  if (!hidl_struct_util::convertHidlNanDataPathInitiatorRequestToLegacy(

      msg, &legacy_msg)) {

    return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);

  }

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->nanDataRequestInitiator(cmd_id, legacy_msg);

      legacy_hal_.lock()->nanDataRequestInitiator(ifname_, cmd_id, legacy_msg);

  return createWifiStatusFromLegacyError(legacy_status);

}

WifiStatus WifiNanIface::respondToDataPathIndicationRequestInternal(

    uint16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg) {

  legacy_hal::NanDataPathIndicationResponse legacy_msg;

  if (!hidl_struct_util::convertHidlNanDataPathIndicationResponseToLegacy(msg, &legacy_msg)) {

  if (!hidl_struct_util::convertHidlNanDataPathIndicationResponseToLegacy(

      msg, &legacy_msg)) {

    return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);

  }

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->nanDataIndicationResponse(cmd_id, legacy_msg);

      legacy_hal_.lock()->nanDataIndicationResponse(

          ifname_, cmd_id, legacy_msg);

  return createWifiStatusFromLegacyError(legacy_status);

}

WifiStatus WifiNanIface::terminateDataPathRequestInternal(

    uint16_t cmd_id, uint32_t ndpInstanceId) {

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->nanDataEnd(cmd_id, ndpInstanceId);

      legacy_hal_.lock()->nanDataEnd(ifname_, cmd_id, ndpInstanceId);

  return createWifiStatusFromLegacyError(legacy_status);

}