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), {}};
   }