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
diff --git a/wifi/1.2/default/wifi_ap_iface.cpp b/wifi/1.2/default/wifi_ap_iface.cpp
index 347ffc6..3da2d66 100644
--- a/wifi/1.2/default/wifi_ap_iface.cpp
+++ b/wifi/1.2/default/wifi_ap_iface.cpp
@@ -85,7 +85,7 @@
 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 @@
   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
diff --git a/wifi/1.2/default/wifi_chip.cpp b/wifi/1.2/default/wifi_chip.cpp
index 07da1dd..f3ff3ed 100644
--- a/wifi/1.2/default/wifi_chip.cpp
+++ b/wifi/1.2/default/wifi_chip.cpp
@@ -412,12 +412,12 @@
   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 @@
   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 @@
 
   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 @@
   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 @@
   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 @@
   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 @@
   }
   legacy_hal::wifi_error legacy_status =
       legacy_hal_.lock()->startRingBufferLogging(
+          getWlan0IfaceName(),
           ring_name,
           static_cast<
               std::underlying_type<WifiDebugRingBufferVerboseLevel>::type>(
@@ -791,13 +793,14 @@
     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 @@
   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 @@
         }
       }
     };
-    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 @@
   };
   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;
diff --git a/wifi/1.2/default/wifi_legacy_hal.cpp b/wifi/1.2/default/wifi_legacy_hal.cpp
index d0d285b..cfb89c2 100644
--- a/wifi/1.2/default/wifi_legacy_hal.cpp
+++ b/wifi/1.2/default/wifi_legacy_hal.cpp
@@ -322,7 +322,6 @@
 
 WifiLegacyHal::WifiLegacyHal()
     : global_handle_(nullptr),
-      wlan_interface_handle_(nullptr),
       awaiting_event_loop_termination_(false),
       is_started_(false) {}
 
@@ -344,7 +343,7 @@
 wifi_error WifiLegacyHal::start() {
   // Ensure that we're starting in a good state.
   CHECK(global_func_table_.wifi_initialize && !global_handle_ &&
-        !wlan_interface_handle_ && !awaiting_event_loop_termination_);
+        iface_name_to_handle_.empty() && !awaiting_event_loop_termination_);
   if (is_started_) {
     LOG(DEBUG) << "Legacy HAL already started";
     return WIFI_SUCCESS;
@@ -360,8 +359,8 @@
     return status;
   }
   std::thread(&WifiLegacyHal::runEventLoop, this).detach();
-  status = retrieveWlanInterfaceHandle();
-  if (status != WIFI_SUCCESS || !wlan_interface_handle_) {
+  status = retrieveIfaceHandles();
+  if (status != WIFI_SUCCESS || iface_name_to_handle_.empty()) {
     LOG(ERROR) << "Failed to retrieve wlan interface handle";
     return status;
   }
@@ -403,24 +402,27 @@
   return WIFI_SUCCESS;
 }
 
-std::pair<wifi_error, std::string> WifiLegacyHal::getDriverVersion() {
+std::pair<wifi_error, std::string> WifiLegacyHal::getDriverVersion(
+    const std::string& iface_name) {
   std::array<char, kMaxVersionStringLength> buffer;
   buffer.fill(0);
   wifi_error status = global_func_table_.wifi_get_driver_version(
-      wlan_interface_handle_, buffer.data(), buffer.size());
+      getIfaceHandle(iface_name), buffer.data(), buffer.size());
   return {status, buffer.data()};
 }
 
-std::pair<wifi_error, std::string> WifiLegacyHal::getFirmwareVersion() {
+std::pair<wifi_error, std::string> WifiLegacyHal::getFirmwareVersion(
+    const std::string& iface_name) {
   std::array<char, kMaxVersionStringLength> buffer;
   buffer.fill(0);
   wifi_error status = global_func_table_.wifi_get_firmware_version(
-      wlan_interface_handle_, buffer.data(), buffer.size());
+      getIfaceHandle(iface_name), buffer.data(), buffer.size());
   return {status, buffer.data()};
 }
 
 std::pair<wifi_error, std::vector<uint8_t>>
-WifiLegacyHal::requestDriverMemoryDump() {
+WifiLegacyHal::requestDriverMemoryDump(
+    const std::string& iface_name) {
   std::vector<uint8_t> driver_dump;
   on_driver_memory_dump_internal_callback = [&driver_dump](char* buffer,
                                                            int buffer_size) {
@@ -429,13 +431,13 @@
                        reinterpret_cast<uint8_t*>(buffer) + buffer_size);
   };
   wifi_error status = global_func_table_.wifi_get_driver_memory_dump(
-      wlan_interface_handle_, {onSyncDriverMemoryDump});
+      getIfaceHandle(iface_name), {onSyncDriverMemoryDump});
   on_driver_memory_dump_internal_callback = nullptr;
   return {status, std::move(driver_dump)};
 }
 
 std::pair<wifi_error, std::vector<uint8_t>>
-WifiLegacyHal::requestFirmwareMemoryDump() {
+WifiLegacyHal::requestFirmwareMemoryDump(const std::string& iface_name) {
   std::vector<uint8_t> firmware_dump;
   on_firmware_memory_dump_internal_callback = [&firmware_dump](
       char* buffer, int buffer_size) {
@@ -444,42 +446,45 @@
                          reinterpret_cast<uint8_t*>(buffer) + buffer_size);
   };
   wifi_error status = global_func_table_.wifi_get_firmware_memory_dump(
-      wlan_interface_handle_, {onSyncFirmwareMemoryDump});
+      getIfaceHandle(iface_name), {onSyncFirmwareMemoryDump});
   on_firmware_memory_dump_internal_callback = nullptr;
   return {status, std::move(firmware_dump)};
 }
 
-std::pair<wifi_error, uint32_t> WifiLegacyHal::getSupportedFeatureSet() {
+std::pair<wifi_error, uint32_t> WifiLegacyHal::getSupportedFeatureSet(
+    const std::string& iface_name) {
   feature_set set;
   static_assert(sizeof(set) == sizeof(uint32_t),
                 "Some features can not be represented in output");
   wifi_error status = global_func_table_.wifi_get_supported_feature_set(
-      wlan_interface_handle_, &set);
+      getIfaceHandle(iface_name), &set);
   return {status, static_cast<uint32_t>(set)};
 }
 
 std::pair<wifi_error, PacketFilterCapabilities>
-WifiLegacyHal::getPacketFilterCapabilities() {
+WifiLegacyHal::getPacketFilterCapabilities(const std::string& iface_name) {
   PacketFilterCapabilities caps;
   wifi_error status = global_func_table_.wifi_get_packet_filter_capabilities(
-      wlan_interface_handle_, &caps.version, &caps.max_len);
+      getIfaceHandle(iface_name), &caps.version, &caps.max_len);
   return {status, caps};
 }
 
-wifi_error WifiLegacyHal::setPacketFilter(const std::vector<uint8_t>& program) {
+wifi_error WifiLegacyHal::setPacketFilter(
+    const std::string& iface_name, const std::vector<uint8_t>& program) {
   return global_func_table_.wifi_set_packet_filter(
-      wlan_interface_handle_, program.data(), program.size());
+      getIfaceHandle(iface_name), program.data(), program.size());
 }
 
 std::pair<wifi_error, wifi_gscan_capabilities>
-WifiLegacyHal::getGscanCapabilities() {
+WifiLegacyHal::getGscanCapabilities(const std::string& iface_name) {
   wifi_gscan_capabilities caps;
   wifi_error status = global_func_table_.wifi_get_gscan_capabilities(
-      wlan_interface_handle_, &caps);
+      getIfaceHandle(iface_name), &caps);
   return {status, caps};
 }
 
 wifi_error WifiLegacyHal::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_user_callback,
@@ -494,7 +499,7 @@
   // This callback will be used to either trigger |on_results_user_callback| or
   // |on_failure_user_callback|.
   on_gscan_event_internal_callback =
-      [on_failure_user_callback, on_results_user_callback, this](
+      [iface_name, on_failure_user_callback, on_results_user_callback, this](
           wifi_request_id id, wifi_scan_event event) {
         switch (event) {
           case WIFI_SCAN_RESULTS_AVAILABLE:
@@ -502,7 +507,8 @@
           case WIFI_SCAN_THRESHOLD_PERCENT: {
             wifi_error status;
             std::vector<wifi_cached_scan_results> cached_scan_results;
-            std::tie(status, cached_scan_results) = getGscanCachedResults();
+            std::tie(status, cached_scan_results) =
+                getGscanCachedResults(iface_name);
             if (status == WIFI_SUCCESS) {
               on_results_user_callback(id, cached_scan_results);
               return;
@@ -529,7 +535,7 @@
   wifi_scan_result_handler handler = {onAsyncGscanFullResult,
                                       onAsyncGscanEvent};
   wifi_error status = global_func_table_.wifi_start_gscan(
-      id, wlan_interface_handle_, params, handler);
+      id, getIfaceHandle(iface_name), params, handler);
   if (status != WIFI_SUCCESS) {
     on_gscan_event_internal_callback = nullptr;
     on_gscan_full_result_internal_callback = nullptr;
@@ -537,7 +543,8 @@
   return status;
 }
 
-wifi_error WifiLegacyHal::stopGscan(wifi_request_id id) {
+wifi_error WifiLegacyHal::stopGscan(
+    const std::string& iface_name, wifi_request_id id) {
   // If there is no an ongoing background scan, reject stop requests.
   // TODO(b/32337212): This needs to be handled by the HIDL object because we
   // need to return the NOT_STARTED error code.
@@ -546,7 +553,7 @@
     return WIFI_ERROR_NOT_AVAILABLE;
   }
   wifi_error status =
-      global_func_table_.wifi_stop_gscan(id, wlan_interface_handle_);
+      global_func_table_.wifi_stop_gscan(id, getIfaceHandle(iface_name));
   // If the request Id is wrong, don't stop the ongoing background scan. Any
   // other error should be treated as the end of background scan.
   if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
@@ -557,14 +564,15 @@
 }
 
 std::pair<wifi_error, std::vector<uint32_t>>
-WifiLegacyHal::getValidFrequenciesForBand(wifi_band band) {
+WifiLegacyHal::getValidFrequenciesForBand(
+    const std::string& iface_name, wifi_band band) {
   static_assert(sizeof(uint32_t) >= sizeof(wifi_channel),
                 "Wifi Channel cannot be represented in output");
   std::vector<uint32_t> freqs;
   freqs.resize(kMaxGscanFrequenciesForBand);
   int32_t num_freqs = 0;
   wifi_error status = global_func_table_.wifi_get_valid_channels(
-      wlan_interface_handle_,
+      getIfaceHandle(iface_name),
       band,
       freqs.size(),
       reinterpret_cast<wifi_channel*>(freqs.data()),
@@ -575,27 +583,31 @@
   return {status, std::move(freqs)};
 }
 
-wifi_error WifiLegacyHal::setDfsFlag(bool dfs_on) {
+wifi_error WifiLegacyHal::setDfsFlag(
+    const std::string& iface_name, bool dfs_on) {
   return global_func_table_.wifi_set_nodfs_flag(
-      wlan_interface_handle_, dfs_on ? 0 : 1);
+      getIfaceHandle(iface_name), dfs_on ? 0 : 1);
 }
 
-wifi_error WifiLegacyHal::enableLinkLayerStats(bool debug) {
+wifi_error WifiLegacyHal::enableLinkLayerStats(
+    const std::string& iface_name, bool debug) {
   wifi_link_layer_params params;
   params.mpdu_size_threshold = kLinkLayerStatsDataMpduSizeThreshold;
   params.aggressive_statistics_gathering = debug;
-  return global_func_table_.wifi_set_link_stats(wlan_interface_handle_, params);
+  return global_func_table_.wifi_set_link_stats(
+      getIfaceHandle(iface_name), params);
 }
 
-wifi_error WifiLegacyHal::disableLinkLayerStats() {
+wifi_error WifiLegacyHal::disableLinkLayerStats(const std::string& iface_name) {
   // TODO: Do we care about these responses?
   uint32_t clear_mask_rsp;
   uint8_t stop_rsp;
   return global_func_table_.wifi_clear_link_stats(
-      wlan_interface_handle_, 0xFFFFFFFF, &clear_mask_rsp, 1, &stop_rsp);
+      getIfaceHandle(iface_name), 0xFFFFFFFF, &clear_mask_rsp, 1, &stop_rsp);
 }
 
-std::pair<wifi_error, LinkLayerStats> WifiLegacyHal::getLinkLayerStats() {
+std::pair<wifi_error, LinkLayerStats> WifiLegacyHal::getLinkLayerStats(
+    const std::string& iface_name) {
   LinkLayerStats link_stats{};
   LinkLayerStats* link_stats_ptr = &link_stats;
 
@@ -632,12 +644,13 @@
       };
 
   wifi_error status = global_func_table_.wifi_get_link_stats(
-      0, wlan_interface_handle_, {onSyncLinkLayerStatsResult});
+      0, getIfaceHandle(iface_name), {onSyncLinkLayerStatsResult});
   on_link_layer_stats_result_internal_callback = nullptr;
   return {status, link_stats};
 }
 
 wifi_error WifiLegacyHal::startRssiMonitoring(
+    const std::string& iface_name,
     wifi_request_id id,
     int8_t max_rssi,
     int8_t min_rssi,
@@ -659,7 +672,7 @@
       };
   wifi_error status = global_func_table_.wifi_start_rssi_monitoring(
       id,
-      wlan_interface_handle_,
+      getIfaceHandle(iface_name),
       max_rssi,
       min_rssi,
       {onAsyncRssiThresholdBreached});
@@ -669,12 +682,14 @@
   return status;
 }
 
-wifi_error WifiLegacyHal::stopRssiMonitoring(wifi_request_id id) {
+wifi_error WifiLegacyHal::stopRssiMonitoring(
+    const std::string& iface_name, wifi_request_id id) {
   if (!on_rssi_threshold_breached_internal_callback) {
     return WIFI_ERROR_NOT_AVAILABLE;
   }
   wifi_error status =
-      global_func_table_.wifi_stop_rssi_monitoring(id, wlan_interface_handle_);
+      global_func_table_.wifi_stop_rssi_monitoring(
+          id, getIfaceHandle(iface_name));
   // If the request Id is wrong, don't stop the ongoing rssi monitoring. Any
   // other error should be treated as the end of background scan.
   if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
@@ -684,30 +699,34 @@
 }
 
 std::pair<wifi_error, wifi_roaming_capabilities>
-WifiLegacyHal::getRoamingCapabilities() {
+WifiLegacyHal::getRoamingCapabilities(const std::string& iface_name) {
   wifi_roaming_capabilities caps;
   wifi_error status = global_func_table_.wifi_get_roaming_capabilities(
-      wlan_interface_handle_, &caps);
+      getIfaceHandle(iface_name), &caps);
   return {status, caps};
 }
 
-wifi_error WifiLegacyHal::configureRoaming(const wifi_roaming_config& config) {
+wifi_error WifiLegacyHal::configureRoaming(
+    const std::string& iface_name, const wifi_roaming_config& config) {
   wifi_roaming_config config_internal = config;
-  return global_func_table_.wifi_configure_roaming(wlan_interface_handle_,
-                                                   &config_internal);
+  return global_func_table_.wifi_configure_roaming(
+      getIfaceHandle(iface_name), &config_internal);
 }
 
-wifi_error WifiLegacyHal::enableFirmwareRoaming(fw_roaming_state_t state) {
-  return global_func_table_.wifi_enable_firmware_roaming(wlan_interface_handle_,
-                                                         state);
+wifi_error WifiLegacyHal::enableFirmwareRoaming(
+    const std::string& iface_name, fw_roaming_state_t state) {
+  return global_func_table_.wifi_enable_firmware_roaming(
+      getIfaceHandle(iface_name), state);
 }
 
-wifi_error WifiLegacyHal::configureNdOffload(bool enable) {
-  return global_func_table_.wifi_configure_nd_offload(wlan_interface_handle_,
-                                                      enable);
+wifi_error WifiLegacyHal::configureNdOffload(
+    const std::string& iface_name, bool enable) {
+  return global_func_table_.wifi_configure_nd_offload(
+      getIfaceHandle(iface_name), enable);
 }
 
 wifi_error WifiLegacyHal::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,
@@ -720,7 +739,7 @@
       dst_address.data(), dst_address.data() + dst_address.size());
   return global_func_table_.wifi_start_sending_offloaded_packet(
       cmd_id,
-      wlan_interface_handle_,
+      getIfaceHandle(iface_name),
       ip_packet_data_internal.data(),
       ip_packet_data_internal.size(),
       src_address_internal.data(),
@@ -728,45 +747,51 @@
       period_in_ms);
 }
 
-wifi_error WifiLegacyHal::stopSendingOffloadedPacket(uint32_t cmd_id) {
+wifi_error WifiLegacyHal::stopSendingOffloadedPacket(
+    const std::string& iface_name, uint32_t cmd_id) {
   return global_func_table_.wifi_stop_sending_offloaded_packet(
-      cmd_id, wlan_interface_handle_);
+      cmd_id, getIfaceHandle(iface_name));
 }
 
-wifi_error WifiLegacyHal::setScanningMacOui(const std::array<uint8_t, 3>& oui) {
+wifi_error WifiLegacyHal::setScanningMacOui(
+    const std::string& iface_name, const std::array<uint8_t, 3>& oui) {
   std::vector<uint8_t> oui_internal(oui.data(), oui.data() + oui.size());
-  return global_func_table_.wifi_set_scanning_mac_oui(wlan_interface_handle_,
-                                                      oui_internal.data());
+  return global_func_table_.wifi_set_scanning_mac_oui(
+      getIfaceHandle(iface_name), oui_internal.data());
 }
 
-wifi_error WifiLegacyHal::selectTxPowerScenario(wifi_power_scenario scenario) {
+wifi_error WifiLegacyHal::selectTxPowerScenario(
+    const std::string& iface_name, wifi_power_scenario scenario) {
   return global_func_table_.wifi_select_tx_power_scenario(
-      wlan_interface_handle_, scenario);
+      getIfaceHandle(iface_name), scenario);
 }
 
-wifi_error WifiLegacyHal::resetTxPowerScenario() {
-  return global_func_table_.wifi_reset_tx_power_scenario(wlan_interface_handle_);
+wifi_error WifiLegacyHal::resetTxPowerScenario(const std::string& iface_name) {
+  return global_func_table_.wifi_reset_tx_power_scenario(
+      getIfaceHandle(iface_name));
 }
 
-std::pair<wifi_error, uint32_t> WifiLegacyHal::getLoggerSupportedFeatureSet() {
+std::pair<wifi_error, uint32_t> WifiLegacyHal::getLoggerSupportedFeatureSet(
+    const std::string& iface_name) {
   uint32_t supported_features;
   wifi_error status = global_func_table_.wifi_get_logger_supported_feature_set(
-      wlan_interface_handle_, &supported_features);
+      getIfaceHandle(iface_name), &supported_features);
   return {status, supported_features};
 }
 
-wifi_error WifiLegacyHal::startPktFateMonitoring() {
+wifi_error WifiLegacyHal::startPktFateMonitoring(
+    const std::string& iface_name) {
   return global_func_table_.wifi_start_pkt_fate_monitoring(
-      wlan_interface_handle_);
+      getIfaceHandle(iface_name));
 }
 
 std::pair<wifi_error, std::vector<wifi_tx_report>>
-WifiLegacyHal::getTxPktFates() {
+WifiLegacyHal::getTxPktFates(const std::string& iface_name) {
   std::vector<wifi_tx_report> tx_pkt_fates;
   tx_pkt_fates.resize(MAX_FATE_LOG_LEN);
   size_t num_fates = 0;
   wifi_error status =
-      global_func_table_.wifi_get_tx_pkt_fates(wlan_interface_handle_,
+      global_func_table_.wifi_get_tx_pkt_fates(getIfaceHandle(iface_name),
                                                tx_pkt_fates.data(),
                                                tx_pkt_fates.size(),
                                                &num_fates);
@@ -776,12 +801,12 @@
 }
 
 std::pair<wifi_error, std::vector<wifi_rx_report>>
-WifiLegacyHal::getRxPktFates() {
+WifiLegacyHal::getRxPktFates(const std::string& iface_name) {
   std::vector<wifi_rx_report> rx_pkt_fates;
   rx_pkt_fates.resize(MAX_FATE_LOG_LEN);
   size_t num_fates = 0;
   wifi_error status =
-      global_func_table_.wifi_get_rx_pkt_fates(wlan_interface_handle_,
+      global_func_table_.wifi_get_rx_pkt_fates(getIfaceHandle(iface_name),
                                                rx_pkt_fates.data(),
                                                rx_pkt_fates.size(),
                                                &num_fates);
@@ -790,7 +815,8 @@
   return {status, std::move(rx_pkt_fates)};
 }
 
-std::pair<wifi_error, WakeReasonStats> WifiLegacyHal::getWakeReasonStats() {
+std::pair<wifi_error, WakeReasonStats> WifiLegacyHal::getWakeReasonStats(
+    const std::string& iface_name) {
   WakeReasonStats stats;
   stats.cmd_event_wake_cnt.resize(kMaxWakeReasonStatsArraySize);
   stats.driver_fw_local_wake_cnt.resize(kMaxWakeReasonStatsArraySize);
@@ -808,7 +834,7 @@
   stats.wake_reason_cnt.driver_fw_local_wake_cnt_used = 0;
 
   wifi_error status = global_func_table_.wifi_get_wake_reason_stats(
-      wlan_interface_handle_, &stats.wake_reason_cnt);
+      getIfaceHandle(iface_name), &stats.wake_reason_cnt);
 
   CHECK(stats.wake_reason_cnt.cmd_event_wake_cnt_used >= 0 &&
         static_cast<uint32_t>(stats.wake_reason_cnt.cmd_event_wake_cnt_used) <=
@@ -829,6 +855,7 @@
 }
 
 wifi_error WifiLegacyHal::registerRingBufferCallbackHandler(
+    const std::string& iface_name,
     const on_ring_buffer_data_callback& on_user_data_callback) {
   if (on_ring_buffer_data_internal_callback) {
     return WIFI_ERROR_NOT_AVAILABLE;
@@ -846,38 +873,38 @@
     }
   };
   wifi_error status = global_func_table_.wifi_set_log_handler(
-      0, wlan_interface_handle_, {onAsyncRingBufferData});
+      0, getIfaceHandle(iface_name), {onAsyncRingBufferData});
   if (status != WIFI_SUCCESS) {
     on_ring_buffer_data_internal_callback = nullptr;
   }
   return status;
 }
 
-wifi_error WifiLegacyHal::deregisterRingBufferCallbackHandler() {
+wifi_error WifiLegacyHal::deregisterRingBufferCallbackHandler(
+    const std::string& iface_name) {
   if (!on_ring_buffer_data_internal_callback) {
     return WIFI_ERROR_NOT_AVAILABLE;
   }
   on_ring_buffer_data_internal_callback = nullptr;
-  return global_func_table_.wifi_reset_log_handler(0, wlan_interface_handle_);
+  return global_func_table_.wifi_reset_log_handler(0, getIfaceHandle(iface_name));
 }
 
 std::pair<wifi_error, std::vector<wifi_ring_buffer_status>>
-WifiLegacyHal::getRingBuffersStatus() {
+WifiLegacyHal::getRingBuffersStatus(const std::string& iface_name) {
   std::vector<wifi_ring_buffer_status> ring_buffers_status;
   ring_buffers_status.resize(kMaxRingBuffers);
   uint32_t num_rings = kMaxRingBuffers;
   wifi_error status = global_func_table_.wifi_get_ring_buffers_status(
-      wlan_interface_handle_, &num_rings, ring_buffers_status.data());
+      getIfaceHandle(iface_name), &num_rings, ring_buffers_status.data());
   CHECK(num_rings <= kMaxRingBuffers);
   ring_buffers_status.resize(num_rings);
   return {status, std::move(ring_buffers_status)};
 }
 
-wifi_error WifiLegacyHal::startRingBufferLogging(const std::string& ring_name,
-                                                 uint32_t verbose_level,
-                                                 uint32_t max_interval_sec,
-                                                 uint32_t min_data_size) {
-  return global_func_table_.wifi_start_logging(wlan_interface_handle_,
+wifi_error WifiLegacyHal::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) {
+  return global_func_table_.wifi_start_logging(getIfaceHandle(iface_name),
                                                verbose_level,
                                                0,
                                                max_interval_sec,
@@ -885,12 +912,14 @@
                                                makeCharVec(ring_name).data());
 }
 
-wifi_error WifiLegacyHal::getRingBufferData(const std::string& ring_name) {
-  return global_func_table_.wifi_get_ring_data(wlan_interface_handle_,
+wifi_error WifiLegacyHal::getRingBufferData(
+    const std::string& iface_name, const std::string& ring_name) {
+  return global_func_table_.wifi_get_ring_data(getIfaceHandle(iface_name),
                                                makeCharVec(ring_name).data());
 }
 
 wifi_error WifiLegacyHal::registerErrorAlertCallbackHandler(
+    const std::string& iface_name,
     const on_error_alert_callback& on_user_alert_callback) {
   if (on_error_alert_internal_callback) {
     return WIFI_ERROR_NOT_AVAILABLE;
@@ -907,22 +936,24 @@
     }
   };
   wifi_error status = global_func_table_.wifi_set_alert_handler(
-      0, wlan_interface_handle_, {onAsyncErrorAlert});
+      0, getIfaceHandle(iface_name), {onAsyncErrorAlert});
   if (status != WIFI_SUCCESS) {
     on_error_alert_internal_callback = nullptr;
   }
   return status;
 }
 
-wifi_error WifiLegacyHal::deregisterErrorAlertCallbackHandler() {
+wifi_error WifiLegacyHal::deregisterErrorAlertCallbackHandler(
+    const std::string& iface_name) {
   if (!on_error_alert_internal_callback) {
     return WIFI_ERROR_NOT_AVAILABLE;
   }
   on_error_alert_internal_callback = nullptr;
-  return global_func_table_.wifi_reset_alert_handler(0, wlan_interface_handle_);
+  return global_func_table_.wifi_reset_alert_handler(0, getIfaceHandle(iface_name));
 }
 
 wifi_error WifiLegacyHal::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_user_callback) {
@@ -950,7 +981,7 @@
   std::vector<wifi_rtt_config> rtt_configs_internal(rtt_configs);
   wifi_error status =
       global_func_table_.wifi_rtt_range_request(id,
-                                                wlan_interface_handle_,
+                                                getIfaceHandle(iface_name),
                                                 rtt_configs.size(),
                                                 rtt_configs_internal.data(),
                                                 {onAsyncRttResults});
@@ -961,7 +992,8 @@
 }
 
 wifi_error WifiLegacyHal::cancelRttRangeRequest(
-    wifi_request_id id, const std::vector<std::array<uint8_t, 6>>& mac_addrs) {
+    const std::string& iface_name, wifi_request_id id,
+    const std::vector<std::array<uint8_t, 6>>& mac_addrs) {
   if (!on_rtt_results_internal_callback) {
     return WIFI_ERROR_NOT_AVAILABLE;
   }
@@ -972,7 +1004,7 @@
   std::vector<std::array<uint8_t, 6>> mac_addrs_internal(mac_addrs);
   wifi_error status = global_func_table_.wifi_rtt_range_cancel(
       id,
-      wlan_interface_handle_,
+      getIfaceHandle(iface_name),
       mac_addrs.size(),
       reinterpret_cast<mac_addr*>(mac_addrs_internal.data()));
   // If the request Id is wrong, don't stop the ongoing range request. Any
@@ -984,53 +1016,58 @@
 }
 
 std::pair<wifi_error, wifi_rtt_capabilities>
-WifiLegacyHal::getRttCapabilities() {
+WifiLegacyHal::getRttCapabilities(const std::string& iface_name) {
   wifi_rtt_capabilities rtt_caps;
   wifi_error status = global_func_table_.wifi_get_rtt_capabilities(
-      wlan_interface_handle_, &rtt_caps);
+      getIfaceHandle(iface_name), &rtt_caps);
   return {status, rtt_caps};
 }
 
-std::pair<wifi_error, wifi_rtt_responder> WifiLegacyHal::getRttResponderInfo() {
+std::pair<wifi_error, wifi_rtt_responder> WifiLegacyHal::getRttResponderInfo(
+    const std::string& iface_name) {
   wifi_rtt_responder rtt_responder;
   wifi_error status = global_func_table_.wifi_rtt_get_responder_info(
-      wlan_interface_handle_, &rtt_responder);
+      getIfaceHandle(iface_name), &rtt_responder);
   return {status, rtt_responder};
 }
 
 wifi_error WifiLegacyHal::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_rtt_responder info_internal(info);
   return global_func_table_.wifi_enable_responder(id,
-                                                  wlan_interface_handle_,
+                                                  getIfaceHandle(iface_name),
                                                   channel_hint,
                                                   max_duration_secs,
                                                   &info_internal);
 }
 
-wifi_error WifiLegacyHal::disableRttResponder(wifi_request_id id) {
-  return global_func_table_.wifi_disable_responder(id, wlan_interface_handle_);
+wifi_error WifiLegacyHal::disableRttResponder(
+    const std::string& iface_name, wifi_request_id id) {
+  return global_func_table_.wifi_disable_responder(id, getIfaceHandle(iface_name));
 }
 
-wifi_error WifiLegacyHal::setRttLci(wifi_request_id id,
-                                    const wifi_lci_information& info) {
+wifi_error WifiLegacyHal::setRttLci(
+    const std::string& iface_name, wifi_request_id id,
+    const wifi_lci_information& info) {
   wifi_lci_information info_internal(info);
   return global_func_table_.wifi_set_lci(
-      id, wlan_interface_handle_, &info_internal);
+      id, getIfaceHandle(iface_name), &info_internal);
 }
 
-wifi_error WifiLegacyHal::setRttLcr(wifi_request_id id,
-                                    const wifi_lcr_information& info) {
+wifi_error WifiLegacyHal::setRttLcr(
+    const std::string& iface_name, wifi_request_id id,
+    const wifi_lcr_information& info) {
   wifi_lcr_information info_internal(info);
   return global_func_table_.wifi_set_lcr(
-      id, wlan_interface_handle_, &info_internal);
+      id, getIfaceHandle(iface_name), &info_internal);
 }
 
 wifi_error WifiLegacyHal::nanRegisterCallbackHandlers(
-    const NanCallbackHandlers& user_callbacks) {
+    const std::string& iface_name, const NanCallbackHandlers& user_callbacks) {
   on_nan_notify_response_user_callback = user_callbacks.on_notify_response;
   on_nan_event_publish_terminated_user_callback =
       user_callbacks.on_event_publish_terminated;
@@ -1060,7 +1097,7 @@
       user_callbacks.on_event_range_report;
 
   return global_func_table_.wifi_nan_register_handler(
-      wlan_interface_handle_,
+      getIfaceHandle(iface_name),
       {onAysncNanNotifyResponse,
        onAysncNanEventPublishReplied,
        onAysncNanEventPublishTerminated,
@@ -1080,79 +1117,90 @@
        onAysncNanEventRangeReport});
 }
 
-wifi_error WifiLegacyHal::nanEnableRequest(transaction_id id,
-                                           const NanEnableRequest& msg) {
+wifi_error WifiLegacyHal::nanEnableRequest(
+    const std::string& iface_name, transaction_id id,
+    const NanEnableRequest& msg) {
   NanEnableRequest msg_internal(msg);
   return global_func_table_.wifi_nan_enable_request(
-      id, wlan_interface_handle_, &msg_internal);
+      id, getIfaceHandle(iface_name), &msg_internal);
 }
 
-wifi_error WifiLegacyHal::nanDisableRequest(transaction_id id) {
-  return global_func_table_.wifi_nan_disable_request(id,
-                                                     wlan_interface_handle_);
+wifi_error WifiLegacyHal::nanDisableRequest(
+    const std::string& iface_name, transaction_id id) {
+  return global_func_table_.wifi_nan_disable_request(
+      id, getIfaceHandle(iface_name));
 }
 
-wifi_error WifiLegacyHal::nanPublishRequest(transaction_id id,
-                                            const NanPublishRequest& msg) {
+wifi_error WifiLegacyHal::nanPublishRequest(
+    const std::string& iface_name, transaction_id id,
+    const NanPublishRequest& msg) {
   NanPublishRequest msg_internal(msg);
   return global_func_table_.wifi_nan_publish_request(
-      id, wlan_interface_handle_, &msg_internal);
+      id, getIfaceHandle(iface_name), &msg_internal);
 }
 
 wifi_error WifiLegacyHal::nanPublishCancelRequest(
-    transaction_id id, const NanPublishCancelRequest& msg) {
+    const std::string& iface_name, transaction_id id,
+    const NanPublishCancelRequest& msg) {
   NanPublishCancelRequest msg_internal(msg);
   return global_func_table_.wifi_nan_publish_cancel_request(
-      id, wlan_interface_handle_, &msg_internal);
+      id, getIfaceHandle(iface_name), &msg_internal);
 }
 
-wifi_error WifiLegacyHal::nanSubscribeRequest(transaction_id id,
-                                              const NanSubscribeRequest& msg) {
+wifi_error WifiLegacyHal::nanSubscribeRequest(
+    const std::string& iface_name, transaction_id id,
+    const NanSubscribeRequest& msg) {
   NanSubscribeRequest msg_internal(msg);
   return global_func_table_.wifi_nan_subscribe_request(
-      id, wlan_interface_handle_, &msg_internal);
+      id, getIfaceHandle(iface_name), &msg_internal);
 }
 
 wifi_error WifiLegacyHal::nanSubscribeCancelRequest(
-    transaction_id id, const NanSubscribeCancelRequest& msg) {
+    const std::string& iface_name, transaction_id id,
+    const NanSubscribeCancelRequest& msg) {
   NanSubscribeCancelRequest msg_internal(msg);
   return global_func_table_.wifi_nan_subscribe_cancel_request(
-      id, wlan_interface_handle_, &msg_internal);
+      id, getIfaceHandle(iface_name), &msg_internal);
 }
 
 wifi_error WifiLegacyHal::nanTransmitFollowupRequest(
-    transaction_id id, const NanTransmitFollowupRequest& msg) {
+    const std::string& iface_name, transaction_id id,
+    const NanTransmitFollowupRequest& msg) {
   NanTransmitFollowupRequest msg_internal(msg);
   return global_func_table_.wifi_nan_transmit_followup_request(
-      id, wlan_interface_handle_, &msg_internal);
+      id, getIfaceHandle(iface_name), &msg_internal);
 }
 
-wifi_error WifiLegacyHal::nanStatsRequest(transaction_id id,
-                                          const NanStatsRequest& msg) {
+wifi_error WifiLegacyHal::nanStatsRequest(
+    const std::string& iface_name, transaction_id id,
+    const NanStatsRequest& msg) {
   NanStatsRequest msg_internal(msg);
   return global_func_table_.wifi_nan_stats_request(
-      id, wlan_interface_handle_, &msg_internal);
+      id, getIfaceHandle(iface_name), &msg_internal);
 }
 
-wifi_error WifiLegacyHal::nanConfigRequest(transaction_id id,
-                                           const NanConfigRequest& msg) {
+wifi_error WifiLegacyHal::nanConfigRequest(
+    const std::string& iface_name, transaction_id id,
+    const NanConfigRequest& msg) {
   NanConfigRequest msg_internal(msg);
   return global_func_table_.wifi_nan_config_request(
-      id, wlan_interface_handle_, &msg_internal);
+      id, getIfaceHandle(iface_name), &msg_internal);
 }
 
-wifi_error WifiLegacyHal::nanTcaRequest(transaction_id id,
-                                        const NanTCARequest& msg) {
+wifi_error WifiLegacyHal::nanTcaRequest(
+    const std::string& iface_name, transaction_id id,
+    const NanTCARequest& msg) {
   NanTCARequest msg_internal(msg);
   return global_func_table_.wifi_nan_tca_request(
-      id, wlan_interface_handle_, &msg_internal);
+      id, getIfaceHandle(iface_name), &msg_internal);
 }
 
 wifi_error WifiLegacyHal::nanBeaconSdfPayloadRequest(
-    transaction_id id, const NanBeaconSdfPayloadRequest& msg) {
+    const std::string& iface_name, transaction_id id,
+    const NanBeaconSdfPayloadRequest& msg) {
   NanBeaconSdfPayloadRequest msg_internal(msg);
   return global_func_table_.wifi_nan_beacon_sdf_payload_request(
-      id, wlan_interface_handle_, &msg_internal);
+      id, getIfaceHandle(iface_name), &msg_internal);
 }
 
 std::pair<wifi_error, NanVersion> WifiLegacyHal::nanGetVersion() {
@@ -1162,35 +1210,40 @@
   return {status, version};
 }
 
-wifi_error WifiLegacyHal::nanGetCapabilities(transaction_id id) {
-  return global_func_table_.wifi_nan_get_capabilities(id,
-                                                      wlan_interface_handle_);
+wifi_error WifiLegacyHal::nanGetCapabilities(
+    const std::string& iface_name, transaction_id id) {
+  return global_func_table_.wifi_nan_get_capabilities(
+      id, getIfaceHandle(iface_name));
 }
 
 wifi_error WifiLegacyHal::nanDataInterfaceCreate(
-    transaction_id id, const std::string& iface_name) {
+    const std::string& iface_name, transaction_id id,
+    const std::string& data_iface_name) {
   return global_func_table_.wifi_nan_data_interface_create(
-      id, wlan_interface_handle_, makeCharVec(iface_name).data());
+      id, getIfaceHandle(iface_name), makeCharVec(data_iface_name).data());
 }
 
 wifi_error WifiLegacyHal::nanDataInterfaceDelete(
-    transaction_id id, const std::string& iface_name) {
+    const std::string& iface_name, transaction_id id,
+    const std::string& data_iface_name) {
   return global_func_table_.wifi_nan_data_interface_delete(
-      id, wlan_interface_handle_, makeCharVec(iface_name).data());
+      id, getIfaceHandle(iface_name), makeCharVec(data_iface_name).data());
 }
 
 wifi_error WifiLegacyHal::nanDataRequestInitiator(
-    transaction_id id, const NanDataPathInitiatorRequest& msg) {
+    const std::string& iface_name, transaction_id id,
+    const NanDataPathInitiatorRequest& msg) {
   NanDataPathInitiatorRequest msg_internal(msg);
   return global_func_table_.wifi_nan_data_request_initiator(
-      id, wlan_interface_handle_, &msg_internal);
+      id, getIfaceHandle(iface_name), &msg_internal);
 }
 
 wifi_error WifiLegacyHal::nanDataIndicationResponse(
-    transaction_id id, const NanDataPathIndicationResponse& msg) {
+    const std::string& iface_name, transaction_id id,
+    const NanDataPathIndicationResponse& msg) {
   NanDataPathIndicationResponse msg_internal(msg);
   return global_func_table_.wifi_nan_data_indication_response(
-      id, wlan_interface_handle_, &msg_internal);
+      id, getIfaceHandle(iface_name), &msg_internal);
 }
 
 typedef struct {
@@ -1198,24 +1251,25 @@
     NanDataPathId ndp_instance_id;
 } NanDataPathEndSingleNdpIdRequest;
 
-wifi_error WifiLegacyHal::nanDataEnd(transaction_id id,
-                                     uint32_t ndpInstanceId) {
+wifi_error WifiLegacyHal::nanDataEnd(
+    const std::string& iface_name, transaction_id id,
+    uint32_t ndpInstanceId) {
   NanDataPathEndSingleNdpIdRequest msg;
   msg.num_ndp_instances = 1;
   msg.ndp_instance_id = ndpInstanceId;
   wifi_error status = global_func_table_.wifi_nan_data_end(
-      id, wlan_interface_handle_, (NanDataPathEndRequest*)&msg);
+      id, getIfaceHandle(iface_name), (NanDataPathEndRequest*)&msg);
   return status;
 }
 
-wifi_error WifiLegacyHal::setCountryCode(std::array<int8_t, 2> code) {
+wifi_error WifiLegacyHal::setCountryCode(
+    const std::string& iface_name, std::array<int8_t, 2> code) {
   std::string code_str(code.data(), code.data() + code.size());
-  return global_func_table_.wifi_set_country_code(wlan_interface_handle_,
+  return global_func_table_.wifi_set_country_code(getIfaceHandle(iface_name),
                                                   code_str.c_str());
 }
 
-wifi_error WifiLegacyHal::retrieveWlanInterfaceHandle() {
-  const std::string& ifname_to_find = getStaIfaceName();
+wifi_error WifiLegacyHal::retrieveIfaceHandles() {
   wifi_interface_handle* iface_handles = nullptr;
   int num_iface_handles = 0;
   wifi_error status = global_func_table_.wifi_get_ifaces(
@@ -1225,20 +1279,30 @@
     return status;
   }
   for (int i = 0; i < num_iface_handles; ++i) {
-    std::array<char, IFNAMSIZ> current_ifname;
-    current_ifname.fill(0);
+    std::array<char, IFNAMSIZ> iface_name_arr = {};
     status = global_func_table_.wifi_get_iface_name(
-        iface_handles[i], current_ifname.data(), current_ifname.size());
+        iface_handles[i], iface_name_arr.data(), iface_name_arr.size());
     if (status != WIFI_SUCCESS) {
       LOG(WARNING) << "Failed to get interface handle name";
       continue;
     }
-    if (ifname_to_find == current_ifname.data()) {
-      wlan_interface_handle_ = iface_handles[i];
-      return WIFI_SUCCESS;
-    }
+    // Assuming the interface name is null terminated since the legacy HAL
+    // API does not return a size.
+    std::string iface_name(iface_name_arr.data());
+    LOG(INFO) << "Adding interface handle for " << iface_name;
+    iface_name_to_handle_[iface_name] = iface_handles[i];
   }
-  return WIFI_ERROR_UNKNOWN;
+  return WIFI_SUCCESS;
+}
+
+wifi_interface_handle WifiLegacyHal::getIfaceHandle(
+    const std::string& iface_name) {
+  const auto iface_handle_iter = iface_name_to_handle_.find(iface_name);
+  if (iface_handle_iter == iface_name_to_handle_.end()) {
+    LOG(ERROR) << "Unknown iface name: " << iface_name;
+    return nullptr;
+  }
+  return iface_handle_iter->second;
 }
 
 void WifiLegacyHal::runEventLoop() {
@@ -1254,12 +1318,12 @@
 }
 
 std::pair<wifi_error, std::vector<wifi_cached_scan_results>>
-WifiLegacyHal::getGscanCachedResults() {
+WifiLegacyHal::getGscanCachedResults(const std::string& iface_name) {
   std::vector<wifi_cached_scan_results> cached_scan_results;
   cached_scan_results.resize(kMaxCachedGscanResults);
   int32_t num_results = 0;
   wifi_error status = global_func_table_.wifi_get_cached_gscan_results(
-      wlan_interface_handle_,
+      getIfaceHandle(iface_name),
       true /* always flush */,
       cached_scan_results.size(),
       cached_scan_results.data(),
@@ -1284,7 +1348,7 @@
 
 void WifiLegacyHal::invalidate() {
   global_handle_ = nullptr;
-  wlan_interface_handle_ = nullptr;
+  iface_name_to_handle_.clear();
   on_driver_memory_dump_internal_callback = nullptr;
   on_firmware_memory_dump_internal_callback = nullptr;
   on_gscan_event_internal_callback = nullptr;
diff --git a/wifi/1.2/default/wifi_legacy_hal.h b/wifi/1.2/default/wifi_legacy_hal.h
index d68ff55..64e17d1 100644
--- a/wifi/1.2/default/wifi_legacy_hal.h
+++ b/wifi/1.2/default/wifi_legacy_hal.h
@@ -18,6 +18,7 @@
 #define WIFI_LEGACY_HAL_H_
 
 #include <functional>
+#include <map>
 #include <thread>
 #include <vector>
 #include <condition_variable>
@@ -150,16 +151,24 @@
   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 @@
   // 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&
-                                     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 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(
+      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,
-                                    uint32_t min_data_size);
-  wifi_error getRingBufferData(const std::string& ring_name);
+  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& 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 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);
+      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(
+      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,
-                                     const NanPublishCancelRequest& msg);
-  wifi_error nanSubscribeRequest(transaction_id id,
-                                 const NanSubscribeRequest& msg);
-  wifi_error nanSubscribeCancelRequest(transaction_id id,
-                                       const NanSubscribeCancelRequest& msg);
-  wifi_error nanTransmitFollowupRequest(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,
-                                        const NanBeaconSdfPayloadRequest& msg);
+  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(
+      const std::string& iface_name, transaction_id id,
+      const NanSubscribeRequest& msg);
+  wifi_error nanSubscribeCancelRequest(
+      const std::string& iface_name, transaction_id id,
+      const NanSubscribeCancelRequest& msg);
+  wifi_error nanTransmitFollowupRequest(
+      const std::string& iface_name, transaction_id id,
+      const NanTransmitFollowupRequest& msg);
+  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,
-                                     const NanDataPathInitiatorRequest& msg);
+  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_;
diff --git a/wifi/1.2/default/wifi_nan_iface.cpp b/wifi/1.2/default/wifi_nan_iface.cpp
index 93b8902..711c452 100644
--- a/wifi/1.2/default/wifi_nan_iface.cpp
+++ b/wifi/1.2/default/wifi_nan_iface.cpp
@@ -412,7 +412,8 @@
   };
 
   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 @@
 
 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::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 @@
     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 @@
     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 @@
   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 @@
     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 @@
   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);
 }
 
diff --git a/wifi/1.2/default/wifi_rtt_controller.cpp b/wifi/1.2/default/wifi_rtt_controller.cpp
index 8c3bbe2..8639062 100644
--- a/wifi/1.2/default/wifi_rtt_controller.cpp
+++ b/wifi/1.2/default/wifi_rtt_controller.cpp
@@ -194,7 +194,7 @@
   };
   legacy_hal::wifi_error legacy_status =
       legacy_hal_.lock()->startRttRangeRequest(
-          cmd_id, legacy_configs, on_results_callback);
+          ifname_, cmd_id, legacy_configs, on_results_callback);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
@@ -205,7 +205,7 @@
     legacy_addrs.push_back(addr);
   }
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->cancelRttRangeRequest(cmd_id, legacy_addrs);
+      legacy_hal_.lock()->cancelRttRangeRequest(ifname_, cmd_id, legacy_addrs);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
@@ -214,7 +214,7 @@
   legacy_hal::wifi_error legacy_status;
   legacy_hal::wifi_rtt_capabilities legacy_caps;
   std::tie(legacy_status, legacy_caps) =
-      legacy_hal_.lock()->getRttCapabilities();
+      legacy_hal_.lock()->getRttCapabilities(ifname_);
   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     return {createWifiStatusFromLegacyError(legacy_status), {}};
   }
@@ -234,7 +234,7 @@
     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
   }
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->setRttLci(cmd_id, legacy_lci);
+      legacy_hal_.lock()->setRttLci(ifname_, cmd_id, legacy_lci);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
@@ -246,7 +246,7 @@
     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
   }
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->setRttLcr(cmd_id, legacy_lcr);
+      legacy_hal_.lock()->setRttLcr(ifname_, cmd_id, legacy_lcr);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
@@ -255,7 +255,7 @@
   legacy_hal::wifi_error legacy_status;
   legacy_hal::wifi_rtt_responder legacy_responder;
   std::tie(legacy_status, legacy_responder) =
-      legacy_hal_.lock()->getRttResponderInfo();
+      legacy_hal_.lock()->getRttResponderInfo(ifname_);
   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     return {createWifiStatusFromLegacyError(legacy_status), {}};
   }
@@ -283,13 +283,14 @@
     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
   }
   legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableRttResponder(
-      cmd_id, legacy_channel_info, max_duration_seconds, legacy_responder);
+      ifname_, cmd_id, legacy_channel_info, max_duration_seconds,
+      legacy_responder);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
 WifiStatus WifiRttController::disableResponderInternal(uint32_t cmd_id) {
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->disableRttResponder(cmd_id);
+      legacy_hal_.lock()->disableRttResponder(ifname_, cmd_id);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 }  // namespace implementation
diff --git a/wifi/1.2/default/wifi_sta_iface.cpp b/wifi/1.2/default/wifi_sta_iface.cpp
index 3622805..f41b778 100644
--- a/wifi/1.2/default/wifi_sta_iface.cpp
+++ b/wifi/1.2/default/wifi_sta_iface.cpp
@@ -34,7 +34,7 @@
     : ifname_(ifname), legacy_hal_(legacy_hal), is_valid_(true) {
   // Turn on DFS channel usage for STA iface.
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->setDfsFlag(true);
+      legacy_hal_.lock()->setDfsFlag(ifname_, true);
   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     LOG(ERROR) << "Failed to set DFS flag; DFS channels may be unavailable.";
   }
@@ -308,13 +308,13 @@
   legacy_hal::wifi_error legacy_status;
   uint32_t legacy_feature_set;
   std::tie(legacy_status, legacy_feature_set) =
-      legacy_hal_.lock()->getSupportedFeatureSet();
+      legacy_hal_.lock()->getSupportedFeatureSet(ifname_);
   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     return {createWifiStatusFromLegacyError(legacy_status), 0};
   }
   uint32_t legacy_logger_feature_set;
   std::tie(legacy_status, legacy_logger_feature_set) =
-      legacy_hal_.lock()->getLoggerSupportedFeatureSet();
+      legacy_hal_.lock()->getLoggerSupportedFeatureSet(ifname_);
   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     // some devices don't support querying logger feature set
     legacy_logger_feature_set = 0;
@@ -332,7 +332,7 @@
   legacy_hal::wifi_error legacy_status;
   legacy_hal::PacketFilterCapabilities legacy_caps;
   std::tie(legacy_status, legacy_caps) =
-      legacy_hal_.lock()->getPacketFilterCapabilities();
+      legacy_hal_.lock()->getPacketFilterCapabilities(ifname_);
   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     return {createWifiStatusFromLegacyError(legacy_status), {}};
   }
@@ -347,7 +347,7 @@
 WifiStatus WifiStaIface::installApfPacketFilterInternal(
     uint32_t /* cmd_id */, const std::vector<uint8_t>& program) {
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->setPacketFilter(program);
+      legacy_hal_.lock()->setPacketFilter(ifname_, program);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
@@ -356,7 +356,7 @@
   legacy_hal::wifi_error legacy_status;
   legacy_hal::wifi_gscan_capabilities legacy_caps;
   std::tie(legacy_status, legacy_caps) =
-      legacy_hal_.lock()->getGscanCapabilities();
+      legacy_hal_.lock()->getGscanCapabilities(ifname_);
   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     return {createWifiStatusFromLegacyError(legacy_status), {}};
   }
@@ -375,7 +375,7 @@
   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};
 }
 
@@ -443,7 +443,8 @@
     }
   };
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->startGscan(cmd_id,
+      legacy_hal_.lock()->startGscan(ifname_,
+                                     cmd_id,
                                      legacy_params,
                                      on_failure_callback,
                                      on_results_callback,
@@ -452,19 +453,20 @@
 }
 
 WifiStatus WifiStaIface::stopBackgroundScanInternal(uint32_t cmd_id) {
-  legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->stopGscan(cmd_id);
+  legacy_hal::wifi_error legacy_status =
+      legacy_hal_.lock()->stopGscan(ifname_, cmd_id);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
 WifiStatus WifiStaIface::enableLinkLayerStatsCollectionInternal(bool debug) {
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->enableLinkLayerStats(debug);
+      legacy_hal_.lock()->enableLinkLayerStats(ifname_, debug);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
 WifiStatus WifiStaIface::disableLinkLayerStatsCollectionInternal() {
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->disableLinkLayerStats();
+      legacy_hal_.lock()->disableLinkLayerStats(ifname_);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
@@ -473,7 +475,7 @@
   legacy_hal::wifi_error legacy_status;
   legacy_hal::LinkLayerStats legacy_stats;
   std::tie(legacy_status, legacy_stats) =
-      legacy_hal_.lock()->getLinkLayerStats();
+      legacy_hal_.lock()->getLinkLayerStats(ifname_);
   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     return {createWifiStatusFromLegacyError(legacy_status), {}};
   }
@@ -506,13 +508,13 @@
   };
   legacy_hal::wifi_error legacy_status =
       legacy_hal_.lock()->startRssiMonitoring(
-          cmd_id, max_rssi, min_rssi, on_threshold_breached_callback);
+          ifname_, cmd_id, max_rssi, min_rssi, on_threshold_breached_callback);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
 WifiStatus WifiStaIface::stopRssiMonitoringInternal(uint32_t cmd_id) {
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->stopRssiMonitoring(cmd_id);
+      legacy_hal_.lock()->stopRssiMonitoring(ifname_, cmd_id);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
@@ -521,7 +523,7 @@
   legacy_hal::wifi_error legacy_status;
   legacy_hal::wifi_roaming_capabilities legacy_caps;
   std::tie(legacy_status, legacy_caps) =
-      legacy_hal_.lock()->getRoamingCapabilities();
+      legacy_hal_.lock()->getRoamingCapabilities(ifname_);
   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     return {createWifiStatusFromLegacyError(legacy_status), {}};
   }
@@ -541,20 +543,20 @@
     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
   }
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->configureRoaming(legacy_config);
+      legacy_hal_.lock()->configureRoaming(ifname_, legacy_config);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
 WifiStatus WifiStaIface::setRoamingStateInternal(StaRoamingState state) {
   legacy_hal::wifi_error legacy_status =
       legacy_hal_.lock()->enableFirmwareRoaming(
-          hidl_struct_util::convertHidlRoamingStateToLegacy(state));
+          ifname_, hidl_struct_util::convertHidlRoamingStateToLegacy(state));
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
 WifiStatus WifiStaIface::enableNdOffloadInternal(bool enable) {
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->configureNdOffload(enable);
+      legacy_hal_.lock()->configureNdOffload(ifname_, enable);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
@@ -567,26 +569,27 @@
     uint32_t period_in_ms) {
   legacy_hal::wifi_error legacy_status =
       legacy_hal_.lock()->startSendingOffloadedPacket(
-          cmd_id, ip_packet_data, src_address, dst_address, period_in_ms);
+          ifname_, cmd_id, ip_packet_data, src_address, dst_address,
+          period_in_ms);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
 WifiStatus WifiStaIface::stopSendingKeepAlivePacketsInternal(uint32_t cmd_id) {
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->stopSendingOffloadedPacket(cmd_id);
+      legacy_hal_.lock()->stopSendingOffloadedPacket(ifname_, cmd_id);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
 WifiStatus WifiStaIface::setScanningMacOuiInternal(
     const std::array<uint8_t, 3>& oui) {
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->setScanningMacOui(oui);
+      legacy_hal_.lock()->setScanningMacOui(ifname_, oui);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
 WifiStatus WifiStaIface::startDebugPacketFateMonitoringInternal() {
   legacy_hal::wifi_error legacy_status =
-      legacy_hal_.lock()->startPktFateMonitoring();
+      legacy_hal_.lock()->startPktFateMonitoring(ifname_);
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
@@ -594,7 +597,8 @@
 WifiStaIface::getDebugTxPacketFatesInternal() {
   legacy_hal::wifi_error legacy_status;
   std::vector<legacy_hal::wifi_tx_report> legacy_fates;
-  std::tie(legacy_status, legacy_fates) = legacy_hal_.lock()->getTxPktFates();
+  std::tie(legacy_status, legacy_fates) =
+      legacy_hal_.lock()->getTxPktFates(ifname_);
   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     return {createWifiStatusFromLegacyError(legacy_status), {}};
   }
@@ -610,7 +614,8 @@
 WifiStaIface::getDebugRxPacketFatesInternal() {
   legacy_hal::wifi_error legacy_status;
   std::vector<legacy_hal::wifi_rx_report> legacy_fates;
-  std::tie(legacy_status, legacy_fates) = legacy_hal_.lock()->getRxPktFates();
+  std::tie(legacy_status, legacy_fates) =
+      legacy_hal_.lock()->getRxPktFates(ifname_);
   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     return {createWifiStatusFromLegacyError(legacy_status), {}};
   }