diff --git a/wifi/aidl/default/Android.bp b/wifi/1.6/default/Android.bp
similarity index 66%
rename from wifi/aidl/default/Android.bp
rename to wifi/1.6/default/Android.bp
index 441d461..0f98e71 100644
--- a/wifi/aidl/default/Android.bp
+++ b/wifi/1.6/default/Android.bp
@@ -1,4 +1,4 @@
-// Copyright (C) 2022 The Android Open Source Project
+// Copyright (C) 2021 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -36,7 +36,7 @@
 }
 
 wifi_hal_cc_defaults {
-    name: "android.hardware.wifi-service-cppflags-defaults",
+    name: "android.hardware.wifi@1.0-service-cppflags-defaults",
     soong_config_variables: {
         hidl_feature_aware: {
             cppflags: ["-DWIFI_HIDL_FEATURE_AWARE"],
@@ -60,8 +60,8 @@
 }
 
 cc_library_static {
-    name: "android.hardware.wifi-service-lib",
-    defaults: ["android.hardware.wifi-service-cppflags-defaults"],
+    name: "android.hardware.wifi@1.0-service-lib",
+    defaults: ["android.hardware.wifi@1.0-service-cppflags-defaults"],
     proprietary: true,
     compile_multilib: "first",
     cppflags: [
@@ -72,8 +72,8 @@
     // Allow implicit fallthroughs in wifi_legacy_hal.cpp until they are fixed.
     cflags: ["-Wno-error=implicit-fallthrough"],
     srcs: [
-        "aidl_struct_util.cpp",
-        "aidl_sync_util.cpp",
+        "hidl_struct_util.cpp",
+        "hidl_sync_util.cpp",
         "ringbuffer.cpp",
         "wifi.cpp",
         "wifi_ap_iface.cpp",
@@ -93,23 +93,29 @@
 
     shared_libs: [
         "libbase",
-        "libbinder_ndk",
         "libcutils",
+        "libhidlbase",
         "liblog",
         "libnl",
         "libutils",
         "libwifi-hal",
         "libwifi-system-iface",
         "libxml2",
-        "android.hardware.wifi-V1-ndk",
+        "android.hardware.wifi@1.0",
+        "android.hardware.wifi@1.1",
+        "android.hardware.wifi@1.2",
+        "android.hardware.wifi@1.3",
+        "android.hardware.wifi@1.4",
+        "android.hardware.wifi@1.5",
+        "android.hardware.wifi@1.6",
     ],
 
     export_include_dirs: ["."],
 }
 
 cc_binary {
-    name: "android.hardware.wifi-service",
-    vintf_fragments: ["android.hardware.wifi-service.xml"],
+    name: "android.hardware.wifi@1.0-service",
+    vintf_fragments: ["android.hardware.wifi@1.0-service.xml"],
     relative_install_path: "hw",
     proprietary: true,
     cppflags: [
@@ -120,24 +126,30 @@
     srcs: ["service.cpp"],
     shared_libs: [
         "libbase",
-        "libbinder_ndk",
         "libcutils",
+        "libhidlbase",
         "liblog",
         "libnl",
         "libutils",
         "libwifi-hal",
         "libwifi-system-iface",
         "libxml2",
-        "android.hardware.wifi-V1-ndk",
+        "android.hardware.wifi@1.0",
+        "android.hardware.wifi@1.1",
+        "android.hardware.wifi@1.2",
+        "android.hardware.wifi@1.3",
+        "android.hardware.wifi@1.4",
+        "android.hardware.wifi@1.5",
+        "android.hardware.wifi@1.6",
     ],
-    static_libs: ["android.hardware.wifi-service-lib"],
-    init_rc: ["android.hardware.wifi-service.rc"],
+    static_libs: ["android.hardware.wifi@1.0-service-lib"],
+    init_rc: ["android.hardware.wifi@1.0-service.rc"],
 }
 
 cc_binary {
-    name: "android.hardware.wifi-service-lazy",
-    vintf_fragments: ["android.hardware.wifi-service.xml"],
-    overrides: ["android.hardware.wifi-service"],
+    name: "android.hardware.wifi@1.0-service-lazy",
+    vintf_fragments: ["android.hardware.wifi@1.0-service.xml"],
+    overrides: ["android.hardware.wifi@1.0-service"],
     cflags: ["-DLAZY_SERVICE"],
     relative_install_path: "hw",
     proprietary: true,
@@ -149,22 +161,28 @@
     srcs: ["service.cpp"],
     shared_libs: [
         "libbase",
-        "libbinder_ndk",
         "libcutils",
+        "libhidlbase",
         "liblog",
         "libnl",
         "libutils",
         "libwifi-hal",
         "libwifi-system-iface",
         "libxml2",
-        "android.hardware.wifi-V1-ndk",
+        "android.hardware.wifi@1.0",
+        "android.hardware.wifi@1.1",
+        "android.hardware.wifi@1.2",
+        "android.hardware.wifi@1.3",
+        "android.hardware.wifi@1.4",
+        "android.hardware.wifi@1.5",
+        "android.hardware.wifi@1.6",
     ],
-    static_libs: ["android.hardware.wifi-service-lib"],
-    init_rc: ["android.hardware.wifi-service-lazy.rc"],
+    static_libs: ["android.hardware.wifi@1.0-service-lib"],
+    init_rc: ["android.hardware.wifi@1.0-service-lazy.rc"],
 }
 
 cc_test {
-    name: "android.hardware.wifi-service-tests",
+    name: "android.hardware.wifi@1.0-service-tests",
     proprietary: true,
     compile_multilib: "first",
     cppflags: [
@@ -173,7 +191,7 @@
         "-Wextra",
     ],
     srcs: [
-        "tests/aidl_struct_util_unit_tests.cpp",
+        "tests/hidl_struct_util_unit_tests.cpp",
         "tests/main.cpp",
         "tests/mock_interface_tool.cpp",
         "tests/mock_wifi_feature_flags.cpp",
@@ -188,13 +206,19 @@
     static_libs: [
         "libgmock",
         "libgtest",
-        "android.hardware.wifi-V1-ndk",
-        "android.hardware.wifi-service-lib",
+        "android.hardware.wifi@1.0",
+        "android.hardware.wifi@1.1",
+        "android.hardware.wifi@1.2",
+        "android.hardware.wifi@1.3",
+        "android.hardware.wifi@1.4",
+        "android.hardware.wifi@1.5",
+        "android.hardware.wifi@1.6",
+        "android.hardware.wifi@1.0-service-lib",
     ],
     shared_libs: [
         "libbase",
-        "libbinder_ndk",
         "libcutils",
+        "libhidlbase",
         "liblog",
         "libnl",
         "libutils",
@@ -204,11 +228,11 @@
 }
 
 filegroup {
-    name: "default-android.hardware.wifi-service.rc",
-    srcs: ["android.hardware.wifi-service.rc"],
+    name: "default-android.hardware.wifi@1.0-service.rc",
+    srcs: ["android.hardware.wifi@1.0-service.rc"],
 }
 
 filegroup {
-    name: "default-android.hardware.wifi-service.xml",
-    srcs: ["android.hardware.wifi-service.xml"],
+    name: "default-android.hardware.wifi@1.0-service.xml",
+    srcs: ["android.hardware.wifi@1.0-service.xml"],
 }
diff --git a/wifi/aidl/default/THREADING.README b/wifi/1.6/default/THREADING.README
similarity index 82%
rename from wifi/aidl/default/THREADING.README
rename to wifi/1.6/default/THREADING.README
index 45679da..8366ca0 100644
--- a/wifi/aidl/default/THREADING.README
+++ b/wifi/1.6/default/THREADING.README
@@ -1,7 +1,7 @@
 Vendor HAL Threading Model
 ==========================
 The vendor HAL service has two threads:
-1. AIDL thread: This is the main thread which processes all the incoming AIDL
+1. HIDL thread: This is the main thread which processes all the incoming HIDL
 RPC's.
 2. Legacy HAL event loop thread: This is the thread forked off for processing
 the legacy HAL event loop (wifi_event_loop()). This thread is used to process
@@ -11,9 +11,9 @@
 Synchronization Concerns
 ========================
 wifi_legacy_hal.cpp has a bunch of global "C" style functions to handle the
-legacy callbacks. Each of these "C" style functions invokes a corresponding
+legacy callbacks. Each of these "C" style function invokes a corresponding
 "std::function" version of the callback which does the actual processing.
-The variables holding these "std::function" callbacks are reset from the AIDL
+The variables holding these "std::function" callbacks are reset from the HIDL
 thread when they are no longer used. For example: stopGscan() will reset the
 corresponding "on_gscan_*" callback variables which were set when startGscan()
 was invoked. This is not thread safe since these callback variables are
@@ -24,12 +24,12 @@
 Adding a global lock seems to be the most trivial solution to the problem.
 a) All of the asynchronous "C" style callbacks will acquire the global lock
 before invoking the corresponding "std::function" callback variables.
-b) All of the AIDL methods will also acquire the global lock before processing
-(in aidl_return_util::validateAndCall()).
+b) All of the HIDL methods will also acquire the global lock before processing
+(in hidl_return_util::validateAndCall()).
 
 Note: It's important that we only acquire the global lock for asynchronous
 callbacks, because there is no guarantee (or documentation to clarify) that the
 synchronous callbacks are invoked on the same invocation thread. If that is not
 the case in some implementation, we will end up deadlocking the system since the
-AIDL thread would have acquired the global lock which is needed by the
+HIDL thread would have acquired the global lock which is needed by the
 synchronous callback executed on the legacy hal event loop thread.
diff --git a/wifi/1.6/default/android.hardware.wifi@1.0-service-lazy.rc b/wifi/1.6/default/android.hardware.wifi@1.0-service-lazy.rc
new file mode 100644
index 0000000..ee8c818
--- /dev/null
+++ b/wifi/1.6/default/android.hardware.wifi@1.0-service-lazy.rc
@@ -0,0 +1,14 @@
+service vendor.wifi_hal_legacy /vendor/bin/hw/android.hardware.wifi@1.0-service-lazy
+    interface android.hardware.wifi@1.0::IWifi default
+    interface android.hardware.wifi@1.1::IWifi default
+    interface android.hardware.wifi@1.2::IWifi default
+    interface android.hardware.wifi@1.3::IWifi default
+    interface android.hardware.wifi@1.4::IWifi default
+    interface android.hardware.wifi@1.5::IWifi default
+    interface android.hardware.wifi@1.6::IWifi default
+    oneshot
+    disabled
+    class hal
+    capabilities NET_ADMIN NET_RAW SYS_MODULE
+    user wifi
+    group wifi gps
diff --git a/wifi/1.6/default/android.hardware.wifi@1.0-service.rc b/wifi/1.6/default/android.hardware.wifi@1.0-service.rc
new file mode 100644
index 0000000..18f40d0
--- /dev/null
+++ b/wifi/1.6/default/android.hardware.wifi@1.0-service.rc
@@ -0,0 +1,12 @@
+service vendor.wifi_hal_legacy /vendor/bin/hw/android.hardware.wifi@1.0-service
+    interface android.hardware.wifi@1.0::IWifi default
+    interface android.hardware.wifi@1.1::IWifi default
+    interface android.hardware.wifi@1.2::IWifi default
+    interface android.hardware.wifi@1.3::IWifi default
+    interface android.hardware.wifi@1.4::IWifi default
+    interface android.hardware.wifi@1.5::IWifi default
+    interface android.hardware.wifi@1.6::IWifi default
+    class hal
+    capabilities NET_ADMIN NET_RAW SYS_MODULE
+    user wifi
+    group wifi gps
diff --git a/wifi/1.6/default/android.hardware.wifi@1.0-service.xml b/wifi/1.6/default/android.hardware.wifi@1.0-service.xml
new file mode 100644
index 0000000..771fbaa
--- /dev/null
+++ b/wifi/1.6/default/android.hardware.wifi@1.0-service.xml
@@ -0,0 +1,11 @@
+<manifest version="1.0" type="device">
+    <hal format="hidl">
+        <name>android.hardware.wifi</name>
+        <transport>hwbinder</transport>
+        <version>1.6</version>
+        <interface>
+            <name>IWifi</name>
+            <instance>default</instance>
+        </interface>
+    </hal>
+</manifest>
diff --git a/wifi/1.6/default/hidl_callback_util.h b/wifi/1.6/default/hidl_callback_util.h
new file mode 100644
index 0000000..aab0ae5
--- /dev/null
+++ b/wifi/1.6/default/hidl_callback_util.h
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HIDL_CALLBACK_UTIL_H_
+#define HIDL_CALLBACK_UTIL_H_
+
+#include <set>
+
+#include <hidl/HidlSupport.h>
+#include <hidl/HidlTransportSupport.h>
+
+namespace {
+// Type of callback invoked by the death handler.
+using on_death_cb_function = std::function<void(uint64_t)>;
+
+// Private class used to keep track of death of individual
+// callbacks stored in HidlCallbackHandler.
+template <typename CallbackType>
+class HidlDeathHandler : public android::hardware::hidl_death_recipient {
+  public:
+    HidlDeathHandler(const on_death_cb_function& user_cb_function)
+        : cb_function_(user_cb_function) {}
+    ~HidlDeathHandler() = default;
+
+    // Death notification for callbacks.
+    void serviceDied(uint64_t cookie,
+                     const android::wp<android::hidl::base::V1_0::IBase>& /* who */) override {
+        cb_function_(cookie);
+    }
+
+  private:
+    on_death_cb_function cb_function_;
+
+    DISALLOW_COPY_AND_ASSIGN(HidlDeathHandler);
+};
+}  // namespace
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+namespace hidl_callback_util {
+template <typename CallbackType>
+// Provides a class to manage callbacks for the various HIDL interfaces and
+// handle the death of the process hosting each callback.
+class HidlCallbackHandler {
+  public:
+    HidlCallbackHandler()
+        : death_handler_(new HidlDeathHandler<CallbackType>(
+                  std::bind(&HidlCallbackHandler::onObjectDeath, this, std::placeholders::_1))) {}
+    ~HidlCallbackHandler() = default;
+
+    bool addCallback(const sp<CallbackType>& cb) {
+        // TODO(b/33818800): Can't compare proxies yet. So, use the cookie
+        // (callback proxy's raw pointer) to track the death of individual
+        // clients.
+        uint64_t cookie = reinterpret_cast<uint64_t>(cb.get());
+        for (const auto& s : cb_set_) {
+            if (interfacesEqual(cb, s)) {
+                LOG(ERROR) << "Duplicate death notification registration";
+                return true;
+            }
+        }
+        if (!cb->linkToDeath(death_handler_, cookie)) {
+            LOG(ERROR) << "Failed to register death notification";
+            return false;
+        }
+        cb_set_.insert(cb);
+        return true;
+    }
+
+    const std::set<android::sp<CallbackType>>& getCallbacks() { return cb_set_; }
+
+    // Death notification for callbacks.
+    void onObjectDeath(uint64_t cookie) {
+        CallbackType* cb = reinterpret_cast<CallbackType*>(cookie);
+        const auto& iter = cb_set_.find(cb);
+        if (iter == cb_set_.end()) {
+            LOG(ERROR) << "Unknown callback death notification received";
+            return;
+        }
+        cb_set_.erase(iter);
+        LOG(DEBUG) << "Dead callback removed from list";
+    }
+
+    void invalidate() {
+        for (const sp<CallbackType>& cb : cb_set_) {
+            if (!cb->unlinkToDeath(death_handler_)) {
+                LOG(ERROR) << "Failed to deregister death notification";
+            }
+        }
+        cb_set_.clear();
+    }
+
+  private:
+    std::set<sp<CallbackType>> cb_set_;
+    sp<HidlDeathHandler<CallbackType>> death_handler_;
+
+    DISALLOW_COPY_AND_ASSIGN(HidlCallbackHandler);
+};
+
+}  // namespace hidl_callback_util
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
+#endif  // HIDL_CALLBACK_UTIL_H_
diff --git a/wifi/1.6/default/hidl_return_util.h b/wifi/1.6/default/hidl_return_util.h
new file mode 100644
index 0000000..a0efac2
--- /dev/null
+++ b/wifi/1.6/default/hidl_return_util.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HIDL_RETURN_UTIL_H_
+#define HIDL_RETURN_UTIL_H_
+
+#include "hidl_sync_util.h"
+#include "wifi_status_util.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+namespace hidl_return_util {
+using namespace android::hardware::wifi::V1_0;
+
+/**
+ * These utility functions are used to invoke a method on the provided
+ * HIDL interface object.
+ * These functions checks if the provided HIDL interface object is valid.
+ * a) if valid, Invokes the corresponding internal implementation function of
+ * the HIDL method. It then invokes the HIDL continuation callback with
+ * the status and any returned values.
+ * b) if invalid, invokes the HIDL continuation callback with the
+ * provided error status and default values.
+ */
+// Use for HIDL methods which return only an instance of WifiStatus.
+template <typename ObjT, typename WorkFuncT, typename... Args>
+Return<void> validateAndCall(ObjT* obj, WifiStatusCode status_code_if_invalid, WorkFuncT&& work,
+                             const std::function<void(const WifiStatus&)>& hidl_cb,
+                             Args&&... args) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
+    if (obj->isValid()) {
+        hidl_cb((obj->*work)(std::forward<Args>(args)...));
+    } else {
+        hidl_cb(createWifiStatus(status_code_if_invalid));
+    }
+    return Void();
+}
+
+// Use for HIDL methods which return only an instance of WifiStatus.
+// This version passes the global lock acquired to the body of the method.
+// Note: Only used by IWifi::stop() currently.
+template <typename ObjT, typename WorkFuncT, typename... Args>
+Return<void> validateAndCallWithLock(ObjT* obj, WifiStatusCode status_code_if_invalid,
+                                     WorkFuncT&& work,
+                                     const std::function<void(const WifiStatus&)>& hidl_cb,
+                                     Args&&... args) {
+    auto lock = hidl_sync_util::acquireGlobalLock();
+    if (obj->isValid()) {
+        hidl_cb((obj->*work)(&lock, std::forward<Args>(args)...));
+    } else {
+        hidl_cb(createWifiStatus(status_code_if_invalid));
+    }
+    return Void();
+}
+
+// Use for HIDL methods which return instance of WifiStatus and a single return
+// value.
+template <typename ObjT, typename WorkFuncT, typename ReturnT, typename... Args>
+Return<void> validateAndCall(ObjT* obj, WifiStatusCode status_code_if_invalid, WorkFuncT&& work,
+                             const std::function<void(const WifiStatus&, ReturnT)>& hidl_cb,
+                             Args&&... args) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
+    if (obj->isValid()) {
+        const auto& ret_pair = (obj->*work)(std::forward<Args>(args)...);
+        const WifiStatus& status = std::get<0>(ret_pair);
+        const auto& ret_value = std::get<1>(ret_pair);
+        hidl_cb(status, ret_value);
+    } else {
+        hidl_cb(createWifiStatus(status_code_if_invalid),
+                typename std::remove_reference<ReturnT>::type());
+    }
+    return Void();
+}
+
+// Use for HIDL methods which return instance of WifiStatus and 2 return
+// values.
+template <typename ObjT, typename WorkFuncT, typename ReturnT1, typename ReturnT2, typename... Args>
+Return<void> validateAndCall(
+        ObjT* obj, WifiStatusCode status_code_if_invalid, WorkFuncT&& work,
+        const std::function<void(const WifiStatus&, ReturnT1, ReturnT2)>& hidl_cb, Args&&... args) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
+    if (obj->isValid()) {
+        const auto& ret_tuple = (obj->*work)(std::forward<Args>(args)...);
+        const WifiStatus& status = std::get<0>(ret_tuple);
+        const auto& ret_value1 = std::get<1>(ret_tuple);
+        const auto& ret_value2 = std::get<2>(ret_tuple);
+        hidl_cb(status, ret_value1, ret_value2);
+    } else {
+        hidl_cb(createWifiStatus(status_code_if_invalid),
+                typename std::remove_reference<ReturnT1>::type(),
+                typename std::remove_reference<ReturnT2>::type());
+    }
+    return Void();
+}
+
+}  // namespace hidl_return_util
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
+#endif  // HIDL_RETURN_UTIL_H_
diff --git a/wifi/1.6/default/hidl_struct_util.cpp b/wifi/1.6/default/hidl_struct_util.cpp
new file mode 100644
index 0000000..2112b26
--- /dev/null
+++ b/wifi/1.6/default/hidl_struct_util.cpp
@@ -0,0 +1,3007 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <android-base/logging.h>
+#include <utils/SystemClock.h>
+
+#include "hidl_struct_util.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+namespace hidl_struct_util {
+
+using V1_6::NanConfigRequestSupplemental;
+
+WifiChannelWidthInMhz convertLegacyWifiChannelWidthToHidl(legacy_hal::wifi_channel_width type);
+
+hidl_string safeConvertChar(const char* str, size_t max_len) {
+    const char* c = str;
+    size_t size = 0;
+    while (*c && (unsigned char)*c < 128 && size < max_len) {
+        ++size;
+        ++c;
+    }
+    return hidl_string(str, size);
+}
+
+IWifiChip::ChipCapabilityMask convertLegacyLoggerFeatureToHidlChipCapability(uint32_t feature) {
+    using HidlChipCaps = IWifiChip::ChipCapabilityMask;
+    switch (feature) {
+        case legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED:
+            return HidlChipCaps::DEBUG_MEMORY_FIRMWARE_DUMP;
+        case legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED:
+            return HidlChipCaps::DEBUG_MEMORY_DRIVER_DUMP;
+        case legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED:
+            return HidlChipCaps::DEBUG_RING_BUFFER_CONNECT_EVENT;
+        case legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED:
+            return HidlChipCaps::DEBUG_RING_BUFFER_POWER_EVENT;
+        case legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED:
+            return HidlChipCaps::DEBUG_RING_BUFFER_WAKELOCK_EVENT;
+    };
+    CHECK(false) << "Unknown legacy feature: " << feature;
+    return {};
+}
+
+IWifiStaIface::StaIfaceCapabilityMask convertLegacyLoggerFeatureToHidlStaIfaceCapability(
+        uint32_t feature) {
+    using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
+    switch (feature) {
+        case legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED:
+            return HidlStaIfaceCaps::DEBUG_PACKET_FATE;
+    };
+    CHECK(false) << "Unknown legacy feature: " << feature;
+    return {};
+}
+
+V1_5::IWifiChip::ChipCapabilityMask convertLegacyFeatureToHidlChipCapability(uint64_t feature) {
+    using HidlChipCaps = V1_5::IWifiChip::ChipCapabilityMask;
+    switch (feature) {
+        case WIFI_FEATURE_SET_TX_POWER_LIMIT:
+            return HidlChipCaps::SET_TX_POWER_LIMIT;
+        case WIFI_FEATURE_USE_BODY_HEAD_SAR:
+            return HidlChipCaps::USE_BODY_HEAD_SAR;
+        case WIFI_FEATURE_D2D_RTT:
+            return HidlChipCaps::D2D_RTT;
+        case WIFI_FEATURE_D2AP_RTT:
+            return HidlChipCaps::D2AP_RTT;
+        case WIFI_FEATURE_INFRA_60G:
+            return HidlChipCaps::WIGIG;
+        case WIFI_FEATURE_SET_LATENCY_MODE:
+            return HidlChipCaps::SET_LATENCY_MODE;
+        case WIFI_FEATURE_P2P_RAND_MAC:
+            return HidlChipCaps::P2P_RAND_MAC;
+    };
+    CHECK(false) << "Unknown legacy feature: " << feature;
+    return {};
+}
+
+IWifiStaIface::StaIfaceCapabilityMask convertLegacyFeatureToHidlStaIfaceCapability(
+        uint64_t feature) {
+    using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
+    switch (feature) {
+        case WIFI_FEATURE_GSCAN:
+            return HidlStaIfaceCaps::BACKGROUND_SCAN;
+        case WIFI_FEATURE_LINK_LAYER_STATS:
+            return HidlStaIfaceCaps::LINK_LAYER_STATS;
+        case WIFI_FEATURE_RSSI_MONITOR:
+            return HidlStaIfaceCaps::RSSI_MONITOR;
+        case WIFI_FEATURE_CONTROL_ROAMING:
+            return HidlStaIfaceCaps::CONTROL_ROAMING;
+        case WIFI_FEATURE_IE_WHITELIST:
+            return HidlStaIfaceCaps::PROBE_IE_WHITELIST;
+        case WIFI_FEATURE_SCAN_RAND:
+            return HidlStaIfaceCaps::SCAN_RAND;
+        case WIFI_FEATURE_INFRA_5G:
+            return HidlStaIfaceCaps::STA_5G;
+        case WIFI_FEATURE_HOTSPOT:
+            return HidlStaIfaceCaps::HOTSPOT;
+        case WIFI_FEATURE_PNO:
+            return HidlStaIfaceCaps::PNO;
+        case WIFI_FEATURE_TDLS:
+            return HidlStaIfaceCaps::TDLS;
+        case WIFI_FEATURE_TDLS_OFFCHANNEL:
+            return HidlStaIfaceCaps::TDLS_OFFCHANNEL;
+        case WIFI_FEATURE_CONFIG_NDO:
+            return HidlStaIfaceCaps::ND_OFFLOAD;
+        case WIFI_FEATURE_MKEEP_ALIVE:
+            return HidlStaIfaceCaps::KEEP_ALIVE;
+    };
+    CHECK(false) << "Unknown legacy feature: " << feature;
+    return {};
+}
+
+bool convertLegacyFeaturesToHidlChipCapabilities(uint64_t legacy_feature_set,
+                                                 uint32_t legacy_logger_feature_set,
+                                                 uint32_t* hidl_caps) {
+    if (!hidl_caps) {
+        return false;
+    }
+    *hidl_caps = {};
+    using HidlChipCaps = IWifiChip::ChipCapabilityMask;
+    for (const auto feature : {legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED,
+                               legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED,
+                               legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED,
+                               legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED,
+                               legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED}) {
+        if (feature & legacy_logger_feature_set) {
+            *hidl_caps |= convertLegacyLoggerFeatureToHidlChipCapability(feature);
+        }
+    }
+    std::vector<uint64_t> features = {WIFI_FEATURE_SET_TX_POWER_LIMIT,
+                                      WIFI_FEATURE_USE_BODY_HEAD_SAR,
+                                      WIFI_FEATURE_D2D_RTT,
+                                      WIFI_FEATURE_D2AP_RTT,
+                                      WIFI_FEATURE_INFRA_60G,
+                                      WIFI_FEATURE_SET_LATENCY_MODE,
+                                      WIFI_FEATURE_P2P_RAND_MAC};
+    for (const auto feature : features) {
+        if (feature & legacy_feature_set) {
+            *hidl_caps |= convertLegacyFeatureToHidlChipCapability(feature);
+        }
+    }
+
+    // There are no flags for these 3 in the legacy feature set. Adding them to
+    // the set because all the current devices support it.
+    *hidl_caps |= HidlChipCaps::DEBUG_RING_BUFFER_VENDOR_DATA;
+    *hidl_caps |= HidlChipCaps::DEBUG_HOST_WAKE_REASON_STATS;
+    *hidl_caps |= HidlChipCaps::DEBUG_ERROR_ALERTS;
+    return true;
+}
+
+WifiDebugRingBufferFlags convertLegacyDebugRingBufferFlagsToHidl(uint32_t flag) {
+    switch (flag) {
+        case WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES:
+            return WifiDebugRingBufferFlags::HAS_BINARY_ENTRIES;
+        case WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES:
+            return WifiDebugRingBufferFlags::HAS_ASCII_ENTRIES;
+    };
+    CHECK(false) << "Unknown legacy flag: " << flag;
+    return {};
+}
+
+bool convertLegacyDebugRingBufferStatusToHidl(
+        const legacy_hal::wifi_ring_buffer_status& legacy_status,
+        WifiDebugRingBufferStatus* hidl_status) {
+    if (!hidl_status) {
+        return false;
+    }
+    *hidl_status = {};
+    hidl_status->ringName = safeConvertChar(reinterpret_cast<const char*>(legacy_status.name),
+                                            sizeof(legacy_status.name));
+    hidl_status->flags = 0;
+    for (const auto flag :
+         {WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES, WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES}) {
+        if (flag & legacy_status.flags) {
+            hidl_status->flags |= static_cast<std::underlying_type<WifiDebugRingBufferFlags>::type>(
+                    convertLegacyDebugRingBufferFlagsToHidl(flag));
+        }
+    }
+    hidl_status->ringId = legacy_status.ring_id;
+    hidl_status->sizeInBytes = legacy_status.ring_buffer_byte_size;
+    // Calculate free size of the ring the buffer. We don't need to send the
+    // exact read/write pointers that were there in the legacy HAL interface.
+    if (legacy_status.written_bytes >= legacy_status.read_bytes) {
+        hidl_status->freeSizeInBytes = legacy_status.ring_buffer_byte_size -
+                                       (legacy_status.written_bytes - legacy_status.read_bytes);
+    } else {
+        hidl_status->freeSizeInBytes = legacy_status.read_bytes - legacy_status.written_bytes;
+    }
+    hidl_status->verboseLevel = legacy_status.verbose_level;
+    return true;
+}
+
+bool convertLegacyVectorOfDebugRingBufferStatusToHidl(
+        const std::vector<legacy_hal::wifi_ring_buffer_status>& legacy_status_vec,
+        std::vector<WifiDebugRingBufferStatus>* hidl_status_vec) {
+    if (!hidl_status_vec) {
+        return false;
+    }
+    *hidl_status_vec = {};
+    for (const auto& legacy_status : legacy_status_vec) {
+        WifiDebugRingBufferStatus hidl_status;
+        if (!convertLegacyDebugRingBufferStatusToHidl(legacy_status, &hidl_status)) {
+            return false;
+        }
+        hidl_status_vec->push_back(hidl_status);
+    }
+    return true;
+}
+
+bool convertLegacyWakeReasonStatsToHidl(const legacy_hal::WakeReasonStats& legacy_stats,
+                                        WifiDebugHostWakeReasonStats* hidl_stats) {
+    if (!hidl_stats) {
+        return false;
+    }
+    *hidl_stats = {};
+    hidl_stats->totalCmdEventWakeCnt = legacy_stats.wake_reason_cnt.total_cmd_event_wake;
+    hidl_stats->cmdEventWakeCntPerType = legacy_stats.cmd_event_wake_cnt;
+    hidl_stats->totalDriverFwLocalWakeCnt = legacy_stats.wake_reason_cnt.total_driver_fw_local_wake;
+    hidl_stats->driverFwLocalWakeCntPerType = legacy_stats.driver_fw_local_wake_cnt;
+    hidl_stats->totalRxPacketWakeCnt = legacy_stats.wake_reason_cnt.total_rx_data_wake;
+    hidl_stats->rxPktWakeDetails.rxUnicastCnt =
+            legacy_stats.wake_reason_cnt.rx_wake_details.rx_unicast_cnt;
+    hidl_stats->rxPktWakeDetails.rxMulticastCnt =
+            legacy_stats.wake_reason_cnt.rx_wake_details.rx_multicast_cnt;
+    hidl_stats->rxPktWakeDetails.rxBroadcastCnt =
+            legacy_stats.wake_reason_cnt.rx_wake_details.rx_broadcast_cnt;
+    hidl_stats->rxMulticastPkWakeDetails.ipv4RxMulticastAddrCnt =
+            legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info.ipv4_rx_multicast_addr_cnt;
+    hidl_stats->rxMulticastPkWakeDetails.ipv6RxMulticastAddrCnt =
+            legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info.ipv6_rx_multicast_addr_cnt;
+    hidl_stats->rxMulticastPkWakeDetails.otherRxMulticastAddrCnt =
+            legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info.other_rx_multicast_addr_cnt;
+    hidl_stats->rxIcmpPkWakeDetails.icmpPkt =
+            legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp_pkt;
+    hidl_stats->rxIcmpPkWakeDetails.icmp6Pkt =
+            legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_pkt;
+    hidl_stats->rxIcmpPkWakeDetails.icmp6Ra =
+            legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ra;
+    hidl_stats->rxIcmpPkWakeDetails.icmp6Na =
+            legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_na;
+    hidl_stats->rxIcmpPkWakeDetails.icmp6Ns =
+            legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ns;
+    return true;
+}
+
+legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy(
+        V1_1::IWifiChip::TxPowerScenario hidl_scenario) {
+    switch (hidl_scenario) {
+        // This is the only supported scenario for V1_1
+        case V1_1::IWifiChip::TxPowerScenario::VOICE_CALL:
+            return legacy_hal::WIFI_POWER_SCENARIO_VOICE_CALL;
+    };
+    CHECK(false);
+}
+
+legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy_1_2(
+        V1_2::IWifiChip::TxPowerScenario hidl_scenario) {
+    switch (hidl_scenario) {
+        // This is the only supported scenario for V1_1
+        case V1_2::IWifiChip::TxPowerScenario::VOICE_CALL:
+            return legacy_hal::WIFI_POWER_SCENARIO_VOICE_CALL;
+        // Those are the supported scenarios for V1_2
+        case V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF:
+            return legacy_hal::WIFI_POWER_SCENARIO_ON_HEAD_CELL_OFF;
+        case V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_ON:
+            return legacy_hal::WIFI_POWER_SCENARIO_ON_HEAD_CELL_ON;
+        case V1_2::IWifiChip::TxPowerScenario::ON_BODY_CELL_OFF:
+            return legacy_hal::WIFI_POWER_SCENARIO_ON_BODY_CELL_OFF;
+        case V1_2::IWifiChip::TxPowerScenario::ON_BODY_CELL_ON:
+            return legacy_hal::WIFI_POWER_SCENARIO_ON_BODY_CELL_ON;
+    };
+    CHECK(false);
+}
+
+legacy_hal::wifi_latency_mode convertHidlLatencyModeToLegacy(
+        V1_3::IWifiChip::LatencyMode hidl_latency_mode) {
+    switch (hidl_latency_mode) {
+        case V1_3::IWifiChip::LatencyMode::NORMAL:
+            return legacy_hal::WIFI_LATENCY_MODE_NORMAL;
+        case V1_3::IWifiChip::LatencyMode::LOW:
+            return legacy_hal::WIFI_LATENCY_MODE_LOW;
+    }
+    CHECK(false);
+}
+
+bool convertLegacyWifiMacInfoToHidl(
+        const legacy_hal::WifiMacInfo& legacy_mac_info,
+        V1_4::IWifiChipEventCallback::RadioModeInfo* hidl_radio_mode_info) {
+    if (!hidl_radio_mode_info) {
+        return false;
+    }
+    *hidl_radio_mode_info = {};
+
+    hidl_radio_mode_info->radioId = legacy_mac_info.wlan_mac_id;
+    // Convert from bitmask of bands in the legacy HAL to enum value in
+    // the HIDL interface.
+    if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND &&
+        legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND &&
+        legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND) {
+        hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_24GHZ_5GHZ_6GHZ;
+    } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND &&
+               legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
+        hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_5GHZ_6GHZ;
+    } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND) {
+        hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_6GHZ;
+    } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND &&
+               legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
+        hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_24GHZ_5GHZ;
+    } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND) {
+        hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_24GHZ;
+    } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
+        hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_5GHZ;
+    } else {
+        hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_UNSPECIFIED;
+    }
+    std::vector<V1_2::IWifiChipEventCallback::IfaceInfo> iface_info_vec;
+    for (const auto& legacy_iface_info : legacy_mac_info.iface_infos) {
+        V1_2::IWifiChipEventCallback::IfaceInfo iface_info;
+        iface_info.name = legacy_iface_info.name;
+        iface_info.channel = legacy_iface_info.channel;
+        iface_info_vec.push_back(iface_info);
+    }
+    hidl_radio_mode_info->ifaceInfos = iface_info_vec;
+    return true;
+}
+
+uint32_t convertHidlWifiBandToLegacyMacBand(V1_5::WifiBand hidl_band) {
+    switch (hidl_band) {
+        case V1_5::WifiBand::BAND_24GHZ:
+            return legacy_hal::WLAN_MAC_2_4_BAND;
+        case V1_5::WifiBand::BAND_5GHZ:
+        case V1_5::WifiBand::BAND_5GHZ_DFS:
+        case V1_5::WifiBand::BAND_5GHZ_WITH_DFS:
+            return legacy_hal::WLAN_MAC_5_0_BAND;
+        case V1_5::WifiBand::BAND_24GHZ_5GHZ:
+        case V1_5::WifiBand::BAND_24GHZ_5GHZ_WITH_DFS:
+            return (legacy_hal::WLAN_MAC_2_4_BAND | legacy_hal::WLAN_MAC_5_0_BAND);
+        case V1_5::WifiBand::BAND_6GHZ:
+            return legacy_hal::WLAN_MAC_6_0_BAND;
+        case V1_5::WifiBand::BAND_5GHZ_6GHZ:
+            return (legacy_hal::WLAN_MAC_5_0_BAND | legacy_hal::WLAN_MAC_6_0_BAND);
+        case V1_5::WifiBand::BAND_24GHZ_5GHZ_6GHZ:
+        case V1_5::WifiBand::BAND_24GHZ_5GHZ_WITH_DFS_6GHZ:
+            return (legacy_hal::WLAN_MAC_2_4_BAND | legacy_hal::WLAN_MAC_5_0_BAND |
+                    legacy_hal::WLAN_MAC_6_0_BAND);
+        case V1_5::WifiBand::BAND_60GHZ:
+            return legacy_hal::WLAN_MAC_60_0_BAND;
+        default:
+            return (legacy_hal::WLAN_MAC_2_4_BAND | legacy_hal::WLAN_MAC_5_0_BAND |
+                    legacy_hal::WLAN_MAC_6_0_BAND | legacy_hal::WLAN_MAC_60_0_BAND);
+    }
+}
+
+V1_5::WifiBand convertLegacyMacBandToHidlWifiBand(uint32_t band) {
+    switch (band) {
+        case legacy_hal::WLAN_MAC_2_4_BAND:
+            return V1_5::WifiBand::BAND_24GHZ;
+        case legacy_hal::WLAN_MAC_5_0_BAND:
+            return V1_5::WifiBand::BAND_5GHZ;
+        case legacy_hal::WLAN_MAC_6_0_BAND:
+            return V1_5::WifiBand::BAND_6GHZ;
+        case legacy_hal::WLAN_MAC_60_0_BAND:
+            return V1_5::WifiBand::BAND_60GHZ;
+        default:
+            return V1_5::WifiBand::BAND_UNSPECIFIED;
+    }
+}
+
+uint32_t convertHidlWifiIfaceModeToLegacy(uint32_t hidl_iface_mask) {
+    uint32_t legacy_iface_mask = 0;
+    if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_STA) {
+        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_STA);
+    }
+    if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_SOFTAP) {
+        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_SOFTAP);
+    }
+    if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_P2P_CLIENT) {
+        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_P2P_CLIENT);
+    }
+    if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_P2P_GO) {
+        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_P2P_GO);
+    }
+    if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_NAN) {
+        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_NAN);
+    }
+    if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_TDLS) {
+        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_TDLS);
+    }
+    if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_MESH) {
+        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_MESH);
+    }
+    if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_IBSS) {
+        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_IBSS);
+    }
+    return legacy_iface_mask;
+}
+
+uint32_t convertLegacyWifiInterfaceModeToHidl(uint32_t legacy_iface_mask) {
+    uint32_t hidl_iface_mask = 0;
+    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_STA)) {
+        hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_STA;
+    }
+    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_SOFTAP)) {
+        hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_SOFTAP;
+    }
+    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_P2P_CLIENT)) {
+        hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_P2P_CLIENT;
+    }
+    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_P2P_GO)) {
+        hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_P2P_GO;
+    }
+    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_NAN)) {
+        hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_NAN;
+    }
+    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_TDLS)) {
+        hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_TDLS;
+    }
+    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_MESH)) {
+        hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_MESH;
+    }
+    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_IBSS)) {
+        hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_IBSS;
+    }
+    return hidl_iface_mask;
+}
+
+uint32_t convertHidlUsableChannelFilterToLegacy(uint32_t hidl_filter_mask) {
+    uint32_t legacy_filter_mask = 0;
+    if (hidl_filter_mask & V1_5::IWifiChip::UsableChannelFilter::CELLULAR_COEXISTENCE) {
+        legacy_filter_mask |= legacy_hal::WIFI_USABLE_CHANNEL_FILTER_CELLULAR_COEXISTENCE;
+    }
+    if (hidl_filter_mask & V1_5::IWifiChip::UsableChannelFilter::CONCURRENCY) {
+        legacy_filter_mask |= legacy_hal::WIFI_USABLE_CHANNEL_FILTER_CONCURRENCY;
+    }
+    if (hidl_filter_mask & V1_6::IWifiChip::UsableChannelFilter::NAN_INSTANT_MODE) {
+        legacy_filter_mask |= WIFI_USABLE_CHANNEL_FILTER_NAN_INSTANT_MODE;
+    }
+    return legacy_filter_mask;
+}
+
+bool convertLegacyWifiUsableChannelToHidl(
+        const legacy_hal::wifi_usable_channel& legacy_usable_channel,
+        V1_6::WifiUsableChannel* hidl_usable_channel) {
+    if (!hidl_usable_channel) {
+        return false;
+    }
+    *hidl_usable_channel = {};
+    hidl_usable_channel->channel = legacy_usable_channel.freq;
+    hidl_usable_channel->channelBandwidth =
+            convertLegacyWifiChannelWidthToHidl(legacy_usable_channel.width);
+    hidl_usable_channel->ifaceModeMask =
+            convertLegacyWifiInterfaceModeToHidl(legacy_usable_channel.iface_mode_mask);
+
+    return true;
+}
+
+bool convertLegacyWifiUsableChannelsToHidl(
+        const std::vector<legacy_hal::wifi_usable_channel>& legacy_usable_channels,
+        std::vector<V1_6::WifiUsableChannel>* hidl_usable_channels) {
+    if (!hidl_usable_channels) {
+        return false;
+    }
+    *hidl_usable_channels = {};
+    for (const auto& legacy_usable_channel : legacy_usable_channels) {
+        V1_6::WifiUsableChannel hidl_usable_channel;
+        if (!convertLegacyWifiUsableChannelToHidl(legacy_usable_channel, &hidl_usable_channel)) {
+            return false;
+        }
+        hidl_usable_channels->push_back(hidl_usable_channel);
+    }
+    return true;
+}
+
+bool convertLegacyWifiMacInfosToHidl(
+        const std::vector<legacy_hal::WifiMacInfo>& legacy_mac_infos,
+        std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo>* hidl_radio_mode_infos) {
+    if (!hidl_radio_mode_infos) {
+        return false;
+    }
+    *hidl_radio_mode_infos = {};
+
+    for (const auto& legacy_mac_info : legacy_mac_infos) {
+        V1_4::IWifiChipEventCallback::RadioModeInfo hidl_radio_mode_info;
+        if (!convertLegacyWifiMacInfoToHidl(legacy_mac_info, &hidl_radio_mode_info)) {
+            return false;
+        }
+        hidl_radio_mode_infos->push_back(hidl_radio_mode_info);
+    }
+    return true;
+}
+
+bool convertLegacyFeaturesToHidlStaCapabilities(uint64_t legacy_feature_set,
+                                                uint32_t legacy_logger_feature_set,
+                                                uint32_t* hidl_caps) {
+    if (!hidl_caps) {
+        return false;
+    }
+    *hidl_caps = {};
+    using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
+    for (const auto feature : {legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED}) {
+        if (feature & legacy_logger_feature_set) {
+            *hidl_caps |= convertLegacyLoggerFeatureToHidlStaIfaceCapability(feature);
+        }
+    }
+    for (const auto feature :
+         {WIFI_FEATURE_GSCAN, WIFI_FEATURE_LINK_LAYER_STATS, WIFI_FEATURE_RSSI_MONITOR,
+          WIFI_FEATURE_CONTROL_ROAMING, WIFI_FEATURE_IE_WHITELIST, WIFI_FEATURE_SCAN_RAND,
+          WIFI_FEATURE_INFRA_5G, WIFI_FEATURE_HOTSPOT, WIFI_FEATURE_PNO, WIFI_FEATURE_TDLS,
+          WIFI_FEATURE_TDLS_OFFCHANNEL, WIFI_FEATURE_CONFIG_NDO, WIFI_FEATURE_MKEEP_ALIVE}) {
+        if (feature & legacy_feature_set) {
+            *hidl_caps |= convertLegacyFeatureToHidlStaIfaceCapability(feature);
+        }
+    }
+    // There is no flag for this one in the legacy feature set. Adding it to the
+    // set because all the current devices support it.
+    *hidl_caps |= HidlStaIfaceCaps::APF;
+    return true;
+}
+
+bool convertLegacyApfCapabilitiesToHidl(const legacy_hal::PacketFilterCapabilities& legacy_caps,
+                                        StaApfPacketFilterCapabilities* hidl_caps) {
+    if (!hidl_caps) {
+        return false;
+    }
+    *hidl_caps = {};
+    hidl_caps->version = legacy_caps.version;
+    hidl_caps->maxLength = legacy_caps.max_len;
+    return true;
+}
+
+uint8_t convertHidlGscanReportEventFlagToLegacy(
+        StaBackgroundScanBucketEventReportSchemeMask hidl_flag) {
+    using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
+    switch (hidl_flag) {
+        case HidlFlag::EACH_SCAN:
+            return REPORT_EVENTS_EACH_SCAN;
+        case HidlFlag::FULL_RESULTS:
+            return REPORT_EVENTS_FULL_RESULTS;
+        case HidlFlag::NO_BATCH:
+            return REPORT_EVENTS_NO_BATCH;
+    };
+    CHECK(false);
+}
+
+StaScanDataFlagMask convertLegacyGscanDataFlagToHidl(uint8_t legacy_flag) {
+    switch (legacy_flag) {
+        case legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED:
+            return StaScanDataFlagMask::INTERRUPTED;
+    };
+    CHECK(false) << "Unknown legacy flag: " << legacy_flag;
+    // To silence the compiler warning about reaching the end of non-void
+    // function.
+    return {};
+}
+
+bool convertLegacyGscanCapabilitiesToHidl(const legacy_hal::wifi_gscan_capabilities& legacy_caps,
+                                          StaBackgroundScanCapabilities* hidl_caps) {
+    if (!hidl_caps) {
+        return false;
+    }
+    *hidl_caps = {};
+    hidl_caps->maxCacheSize = legacy_caps.max_scan_cache_size;
+    hidl_caps->maxBuckets = legacy_caps.max_scan_buckets;
+    hidl_caps->maxApCachePerScan = legacy_caps.max_ap_cache_per_scan;
+    hidl_caps->maxReportingThreshold = legacy_caps.max_scan_reporting_threshold;
+    return true;
+}
+
+legacy_hal::wifi_band convertHidlWifiBandToLegacy(V1_0::WifiBand band) {
+    switch (band) {
+        case V1_0::WifiBand::BAND_UNSPECIFIED:
+            return legacy_hal::WIFI_BAND_UNSPECIFIED;
+        case V1_0::WifiBand::BAND_24GHZ:
+            return legacy_hal::WIFI_BAND_BG;
+        case V1_0::WifiBand::BAND_5GHZ:
+            return legacy_hal::WIFI_BAND_A;
+        case V1_0::WifiBand::BAND_5GHZ_DFS:
+            return legacy_hal::WIFI_BAND_A_DFS;
+        case V1_0::WifiBand::BAND_5GHZ_WITH_DFS:
+            return legacy_hal::WIFI_BAND_A_WITH_DFS;
+        case V1_0::WifiBand::BAND_24GHZ_5GHZ:
+            return legacy_hal::WIFI_BAND_ABG;
+        case V1_0::WifiBand::BAND_24GHZ_5GHZ_WITH_DFS:
+            return legacy_hal::WIFI_BAND_ABG_WITH_DFS;
+    };
+    CHECK(false);
+}
+
+bool convertHidlGscanParamsToLegacy(const StaBackgroundScanParameters& hidl_scan_params,
+                                    legacy_hal::wifi_scan_cmd_params* legacy_scan_params) {
+    if (!legacy_scan_params) {
+        return false;
+    }
+    *legacy_scan_params = {};
+    legacy_scan_params->base_period = hidl_scan_params.basePeriodInMs;
+    legacy_scan_params->max_ap_per_scan = hidl_scan_params.maxApPerScan;
+    legacy_scan_params->report_threshold_percent = hidl_scan_params.reportThresholdPercent;
+    legacy_scan_params->report_threshold_num_scans = hidl_scan_params.reportThresholdNumScans;
+    if (hidl_scan_params.buckets.size() > MAX_BUCKETS) {
+        return false;
+    }
+    legacy_scan_params->num_buckets = hidl_scan_params.buckets.size();
+    for (uint32_t bucket_idx = 0; bucket_idx < hidl_scan_params.buckets.size(); bucket_idx++) {
+        const StaBackgroundScanBucketParameters& hidl_bucket_spec =
+                hidl_scan_params.buckets[bucket_idx];
+        legacy_hal::wifi_scan_bucket_spec& legacy_bucket_spec =
+                legacy_scan_params->buckets[bucket_idx];
+        if (hidl_bucket_spec.bucketIdx >= MAX_BUCKETS) {
+            return false;
+        }
+        legacy_bucket_spec.bucket = hidl_bucket_spec.bucketIdx;
+        legacy_bucket_spec.band = convertHidlWifiBandToLegacy(hidl_bucket_spec.band);
+        legacy_bucket_spec.period = hidl_bucket_spec.periodInMs;
+        legacy_bucket_spec.max_period = hidl_bucket_spec.exponentialMaxPeriodInMs;
+        legacy_bucket_spec.base = hidl_bucket_spec.exponentialBase;
+        legacy_bucket_spec.step_count = hidl_bucket_spec.exponentialStepCount;
+        legacy_bucket_spec.report_events = 0;
+        using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
+        for (const auto flag : {HidlFlag::EACH_SCAN, HidlFlag::FULL_RESULTS, HidlFlag::NO_BATCH}) {
+            if (hidl_bucket_spec.eventReportScheme &
+                static_cast<std::underlying_type<HidlFlag>::type>(flag)) {
+                legacy_bucket_spec.report_events |= convertHidlGscanReportEventFlagToLegacy(flag);
+            }
+        }
+        if (hidl_bucket_spec.frequencies.size() > MAX_CHANNELS) {
+            return false;
+        }
+        legacy_bucket_spec.num_channels = hidl_bucket_spec.frequencies.size();
+        for (uint32_t freq_idx = 0; freq_idx < hidl_bucket_spec.frequencies.size(); freq_idx++) {
+            legacy_bucket_spec.channels[freq_idx].channel = hidl_bucket_spec.frequencies[freq_idx];
+        }
+    }
+    return true;
+}
+
+bool convertLegacyIeToHidl(const legacy_hal::wifi_information_element& legacy_ie,
+                           WifiInformationElement* hidl_ie) {
+    if (!hidl_ie) {
+        return false;
+    }
+    *hidl_ie = {};
+    hidl_ie->id = legacy_ie.id;
+    hidl_ie->data = std::vector<uint8_t>(legacy_ie.data, legacy_ie.data + legacy_ie.len);
+    return true;
+}
+
+bool convertLegacyIeBlobToHidl(const uint8_t* ie_blob, uint32_t ie_blob_len,
+                               std::vector<WifiInformationElement>* hidl_ies) {
+    if (!ie_blob || !hidl_ies) {
+        return false;
+    }
+    *hidl_ies = {};
+    const uint8_t* ies_begin = ie_blob;
+    const uint8_t* ies_end = ie_blob + ie_blob_len;
+    const uint8_t* next_ie = ies_begin;
+    using wifi_ie = legacy_hal::wifi_information_element;
+    constexpr size_t kIeHeaderLen = sizeof(wifi_ie);
+    // Each IE should atleast have the header (i.e |id| & |len| fields).
+    while (next_ie + kIeHeaderLen <= ies_end) {
+        const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie));
+        uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len;
+        if (next_ie + curr_ie_len > ies_end) {
+            LOG(ERROR) << "Error parsing IE blob. Next IE: " << (void*)next_ie
+                       << ", Curr IE len: " << curr_ie_len << ", IEs End: " << (void*)ies_end;
+            break;
+        }
+        WifiInformationElement hidl_ie;
+        if (!convertLegacyIeToHidl(legacy_ie, &hidl_ie)) {
+            LOG(ERROR) << "Error converting IE. Id: " << legacy_ie.id << ", len: " << legacy_ie.len;
+            break;
+        }
+        hidl_ies->push_back(std::move(hidl_ie));
+        next_ie += curr_ie_len;
+    }
+    // Check if the blob has been fully consumed.
+    if (next_ie != ies_end) {
+        LOG(ERROR) << "Failed to fully parse IE blob. Next IE: " << (void*)next_ie
+                   << ", IEs End: " << (void*)ies_end;
+    }
+    return true;
+}
+
+bool convertLegacyGscanResultToHidl(const legacy_hal::wifi_scan_result& legacy_scan_result,
+                                    bool has_ie_data, StaScanResult* hidl_scan_result) {
+    if (!hidl_scan_result) {
+        return false;
+    }
+    *hidl_scan_result = {};
+    hidl_scan_result->timeStampInUs = legacy_scan_result.ts;
+    hidl_scan_result->ssid = std::vector<uint8_t>(
+            legacy_scan_result.ssid,
+            legacy_scan_result.ssid +
+                    strnlen(legacy_scan_result.ssid, sizeof(legacy_scan_result.ssid) - 1));
+    memcpy(hidl_scan_result->bssid.data(), legacy_scan_result.bssid,
+           hidl_scan_result->bssid.size());
+    hidl_scan_result->frequency = legacy_scan_result.channel;
+    hidl_scan_result->rssi = legacy_scan_result.rssi;
+    hidl_scan_result->beaconPeriodInMs = legacy_scan_result.beacon_period;
+    hidl_scan_result->capability = legacy_scan_result.capability;
+    if (has_ie_data) {
+        std::vector<WifiInformationElement> ies;
+        if (!convertLegacyIeBlobToHidl(reinterpret_cast<const uint8_t*>(legacy_scan_result.ie_data),
+                                       legacy_scan_result.ie_length, &ies)) {
+            return false;
+        }
+        hidl_scan_result->informationElements = std::move(ies);
+    }
+    return true;
+}
+
+bool convertLegacyCachedGscanResultsToHidl(
+        const legacy_hal::wifi_cached_scan_results& legacy_cached_scan_result,
+        StaScanData* hidl_scan_data) {
+    if (!hidl_scan_data) {
+        return false;
+    }
+    *hidl_scan_data = {};
+    hidl_scan_data->flags = 0;
+    for (const auto flag : {legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED}) {
+        if (legacy_cached_scan_result.flags & flag) {
+            hidl_scan_data->flags |= static_cast<std::underlying_type<StaScanDataFlagMask>::type>(
+                    convertLegacyGscanDataFlagToHidl(flag));
+        }
+    }
+    hidl_scan_data->bucketsScanned = legacy_cached_scan_result.buckets_scanned;
+
+    CHECK(legacy_cached_scan_result.num_results >= 0 &&
+          legacy_cached_scan_result.num_results <= MAX_AP_CACHE_PER_SCAN);
+    std::vector<StaScanResult> hidl_scan_results;
+    for (int32_t result_idx = 0; result_idx < legacy_cached_scan_result.num_results; result_idx++) {
+        StaScanResult hidl_scan_result;
+        if (!convertLegacyGscanResultToHidl(legacy_cached_scan_result.results[result_idx], false,
+                                            &hidl_scan_result)) {
+            return false;
+        }
+        hidl_scan_results.push_back(hidl_scan_result);
+    }
+    hidl_scan_data->results = std::move(hidl_scan_results);
+    return true;
+}
+
+bool convertLegacyVectorOfCachedGscanResultsToHidl(
+        const std::vector<legacy_hal::wifi_cached_scan_results>& legacy_cached_scan_results,
+        std::vector<StaScanData>* hidl_scan_datas) {
+    if (!hidl_scan_datas) {
+        return false;
+    }
+    *hidl_scan_datas = {};
+    for (const auto& legacy_cached_scan_result : legacy_cached_scan_results) {
+        StaScanData hidl_scan_data;
+        if (!convertLegacyCachedGscanResultsToHidl(legacy_cached_scan_result, &hidl_scan_data)) {
+            return false;
+        }
+        hidl_scan_datas->push_back(hidl_scan_data);
+    }
+    return true;
+}
+
+WifiDebugTxPacketFate convertLegacyDebugTxPacketFateToHidl(legacy_hal::wifi_tx_packet_fate fate) {
+    switch (fate) {
+        case legacy_hal::TX_PKT_FATE_ACKED:
+            return WifiDebugTxPacketFate::ACKED;
+        case legacy_hal::TX_PKT_FATE_SENT:
+            return WifiDebugTxPacketFate::SENT;
+        case legacy_hal::TX_PKT_FATE_FW_QUEUED:
+            return WifiDebugTxPacketFate::FW_QUEUED;
+        case legacy_hal::TX_PKT_FATE_FW_DROP_INVALID:
+            return WifiDebugTxPacketFate::FW_DROP_INVALID;
+        case legacy_hal::TX_PKT_FATE_FW_DROP_NOBUFS:
+            return WifiDebugTxPacketFate::FW_DROP_NOBUFS;
+        case legacy_hal::TX_PKT_FATE_FW_DROP_OTHER:
+            return WifiDebugTxPacketFate::FW_DROP_OTHER;
+        case legacy_hal::TX_PKT_FATE_DRV_QUEUED:
+            return WifiDebugTxPacketFate::DRV_QUEUED;
+        case legacy_hal::TX_PKT_FATE_DRV_DROP_INVALID:
+            return WifiDebugTxPacketFate::DRV_DROP_INVALID;
+        case legacy_hal::TX_PKT_FATE_DRV_DROP_NOBUFS:
+            return WifiDebugTxPacketFate::DRV_DROP_NOBUFS;
+        case legacy_hal::TX_PKT_FATE_DRV_DROP_OTHER:
+            return WifiDebugTxPacketFate::DRV_DROP_OTHER;
+    };
+    CHECK(false) << "Unknown legacy fate type: " << fate;
+}
+
+WifiDebugRxPacketFate convertLegacyDebugRxPacketFateToHidl(legacy_hal::wifi_rx_packet_fate fate) {
+    switch (fate) {
+        case legacy_hal::RX_PKT_FATE_SUCCESS:
+            return WifiDebugRxPacketFate::SUCCESS;
+        case legacy_hal::RX_PKT_FATE_FW_QUEUED:
+            return WifiDebugRxPacketFate::FW_QUEUED;
+        case legacy_hal::RX_PKT_FATE_FW_DROP_FILTER:
+            return WifiDebugRxPacketFate::FW_DROP_FILTER;
+        case legacy_hal::RX_PKT_FATE_FW_DROP_INVALID:
+            return WifiDebugRxPacketFate::FW_DROP_INVALID;
+        case legacy_hal::RX_PKT_FATE_FW_DROP_NOBUFS:
+            return WifiDebugRxPacketFate::FW_DROP_NOBUFS;
+        case legacy_hal::RX_PKT_FATE_FW_DROP_OTHER:
+            return WifiDebugRxPacketFate::FW_DROP_OTHER;
+        case legacy_hal::RX_PKT_FATE_DRV_QUEUED:
+            return WifiDebugRxPacketFate::DRV_QUEUED;
+        case legacy_hal::RX_PKT_FATE_DRV_DROP_FILTER:
+            return WifiDebugRxPacketFate::DRV_DROP_FILTER;
+        case legacy_hal::RX_PKT_FATE_DRV_DROP_INVALID:
+            return WifiDebugRxPacketFate::DRV_DROP_INVALID;
+        case legacy_hal::RX_PKT_FATE_DRV_DROP_NOBUFS:
+            return WifiDebugRxPacketFate::DRV_DROP_NOBUFS;
+        case legacy_hal::RX_PKT_FATE_DRV_DROP_OTHER:
+            return WifiDebugRxPacketFate::DRV_DROP_OTHER;
+    };
+    CHECK(false) << "Unknown legacy fate type: " << fate;
+}
+
+WifiDebugPacketFateFrameType convertLegacyDebugPacketFateFrameTypeToHidl(
+        legacy_hal::frame_type type) {
+    switch (type) {
+        case legacy_hal::FRAME_TYPE_UNKNOWN:
+            return WifiDebugPacketFateFrameType::UNKNOWN;
+        case legacy_hal::FRAME_TYPE_ETHERNET_II:
+            return WifiDebugPacketFateFrameType::ETHERNET_II;
+        case legacy_hal::FRAME_TYPE_80211_MGMT:
+            return WifiDebugPacketFateFrameType::MGMT_80211;
+    };
+    CHECK(false) << "Unknown legacy frame type: " << type;
+}
+
+bool convertLegacyDebugPacketFateFrameToHidl(const legacy_hal::frame_info& legacy_frame,
+                                             WifiDebugPacketFateFrameInfo* hidl_frame) {
+    if (!hidl_frame) {
+        return false;
+    }
+    *hidl_frame = {};
+    hidl_frame->frameType = convertLegacyDebugPacketFateFrameTypeToHidl(legacy_frame.payload_type);
+    hidl_frame->frameLen = legacy_frame.frame_len;
+    hidl_frame->driverTimestampUsec = legacy_frame.driver_timestamp_usec;
+    hidl_frame->firmwareTimestampUsec = legacy_frame.firmware_timestamp_usec;
+    const uint8_t* frame_begin =
+            reinterpret_cast<const uint8_t*>(legacy_frame.frame_content.ethernet_ii_bytes);
+    hidl_frame->frameContent =
+            std::vector<uint8_t>(frame_begin, frame_begin + legacy_frame.frame_len);
+    return true;
+}
+
+bool convertLegacyDebugTxPacketFateToHidl(const legacy_hal::wifi_tx_report& legacy_fate,
+                                          WifiDebugTxPacketFateReport* hidl_fate) {
+    if (!hidl_fate) {
+        return false;
+    }
+    *hidl_fate = {};
+    hidl_fate->fate = convertLegacyDebugTxPacketFateToHidl(legacy_fate.fate);
+    return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf, &hidl_fate->frameInfo);
+}
+
+bool convertLegacyVectorOfDebugTxPacketFateToHidl(
+        const std::vector<legacy_hal::wifi_tx_report>& legacy_fates,
+        std::vector<WifiDebugTxPacketFateReport>* hidl_fates) {
+    if (!hidl_fates) {
+        return false;
+    }
+    *hidl_fates = {};
+    for (const auto& legacy_fate : legacy_fates) {
+        WifiDebugTxPacketFateReport hidl_fate;
+        if (!convertLegacyDebugTxPacketFateToHidl(legacy_fate, &hidl_fate)) {
+            return false;
+        }
+        hidl_fates->push_back(hidl_fate);
+    }
+    return true;
+}
+
+bool convertLegacyDebugRxPacketFateToHidl(const legacy_hal::wifi_rx_report& legacy_fate,
+                                          WifiDebugRxPacketFateReport* hidl_fate) {
+    if (!hidl_fate) {
+        return false;
+    }
+    *hidl_fate = {};
+    hidl_fate->fate = convertLegacyDebugRxPacketFateToHidl(legacy_fate.fate);
+    return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf, &hidl_fate->frameInfo);
+}
+
+bool convertLegacyVectorOfDebugRxPacketFateToHidl(
+        const std::vector<legacy_hal::wifi_rx_report>& legacy_fates,
+        std::vector<WifiDebugRxPacketFateReport>* hidl_fates) {
+    if (!hidl_fates) {
+        return false;
+    }
+    *hidl_fates = {};
+    for (const auto& legacy_fate : legacy_fates) {
+        WifiDebugRxPacketFateReport hidl_fate;
+        if (!convertLegacyDebugRxPacketFateToHidl(legacy_fate, &hidl_fate)) {
+            return false;
+        }
+        hidl_fates->push_back(hidl_fate);
+    }
+    return true;
+}
+
+bool convertLegacyLinkLayerRadioStatsToHidl(
+        const legacy_hal::LinkLayerRadioStats& legacy_radio_stat,
+        V1_6::StaLinkLayerRadioStats* hidl_radio_stat) {
+    if (!hidl_radio_stat) {
+        return false;
+    }
+    *hidl_radio_stat = {};
+
+    hidl_radio_stat->radioId = legacy_radio_stat.stats.radio;
+    hidl_radio_stat->V1_0.onTimeInMs = legacy_radio_stat.stats.on_time;
+    hidl_radio_stat->V1_0.txTimeInMs = legacy_radio_stat.stats.tx_time;
+    hidl_radio_stat->V1_0.rxTimeInMs = legacy_radio_stat.stats.rx_time;
+    hidl_radio_stat->V1_0.onTimeInMsForScan = legacy_radio_stat.stats.on_time_scan;
+    hidl_radio_stat->V1_0.txTimeInMsPerLevel = legacy_radio_stat.tx_time_per_levels;
+    hidl_radio_stat->onTimeInMsForNanScan = legacy_radio_stat.stats.on_time_nbd;
+    hidl_radio_stat->onTimeInMsForBgScan = legacy_radio_stat.stats.on_time_gscan;
+    hidl_radio_stat->onTimeInMsForRoamScan = legacy_radio_stat.stats.on_time_roam_scan;
+    hidl_radio_stat->onTimeInMsForPnoScan = legacy_radio_stat.stats.on_time_pno_scan;
+    hidl_radio_stat->onTimeInMsForHs20Scan = legacy_radio_stat.stats.on_time_hs20;
+
+    std::vector<V1_6::WifiChannelStats> hidl_channel_stats;
+
+    for (const auto& channel_stat : legacy_radio_stat.channel_stats) {
+        V1_6::WifiChannelStats hidl_channel_stat;
+        hidl_channel_stat.onTimeInMs = channel_stat.on_time;
+        hidl_channel_stat.ccaBusyTimeInMs = channel_stat.cca_busy_time;
+        /*
+         * TODO once b/119142899 is fixed,
+         * replace below code with convertLegacyWifiChannelInfoToHidl()
+         */
+        hidl_channel_stat.channel.width = WifiChannelWidthInMhz::WIDTH_20;
+        hidl_channel_stat.channel.centerFreq = channel_stat.channel.center_freq;
+        hidl_channel_stat.channel.centerFreq0 = channel_stat.channel.center_freq0;
+        hidl_channel_stat.channel.centerFreq1 = channel_stat.channel.center_freq1;
+        hidl_channel_stats.push_back(hidl_channel_stat);
+    }
+
+    hidl_radio_stat->channelStats = hidl_channel_stats;
+
+    return true;
+}
+
+bool convertLegacyLinkLayerStatsToHidl(const legacy_hal::LinkLayerStats& legacy_stats,
+                                       V1_6::StaLinkLayerStats* hidl_stats) {
+    if (!hidl_stats) {
+        return false;
+    }
+    *hidl_stats = {};
+    // iface legacy_stats conversion.
+    hidl_stats->iface.V1_0.beaconRx = legacy_stats.iface.beacon_rx;
+    hidl_stats->iface.V1_0.avgRssiMgmt = legacy_stats.iface.rssi_mgmt;
+    hidl_stats->iface.V1_0.wmeBePktStats.rxMpdu =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu;
+    hidl_stats->iface.V1_0.wmeBePktStats.txMpdu =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu;
+    hidl_stats->iface.V1_0.wmeBePktStats.lostMpdu =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost;
+    hidl_stats->iface.V1_0.wmeBePktStats.retries =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries;
+    hidl_stats->iface.wmeBeContentionTimeStats.contentionTimeMinInUsec =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_min;
+    hidl_stats->iface.wmeBeContentionTimeStats.contentionTimeMaxInUsec =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_max;
+    hidl_stats->iface.wmeBeContentionTimeStats.contentionTimeAvgInUsec =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_avg;
+    hidl_stats->iface.wmeBeContentionTimeStats.contentionNumSamples =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples;
+    hidl_stats->iface.V1_0.wmeBkPktStats.rxMpdu =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu;
+    hidl_stats->iface.V1_0.wmeBkPktStats.txMpdu =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu;
+    hidl_stats->iface.V1_0.wmeBkPktStats.lostMpdu =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost;
+    hidl_stats->iface.V1_0.wmeBkPktStats.retries =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries;
+    hidl_stats->iface.wmeBkContentionTimeStats.contentionTimeMinInUsec =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_min;
+    hidl_stats->iface.wmeBkContentionTimeStats.contentionTimeMaxInUsec =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_max;
+    hidl_stats->iface.wmeBkContentionTimeStats.contentionTimeAvgInUsec =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_avg;
+    hidl_stats->iface.wmeBkContentionTimeStats.contentionNumSamples =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples;
+    hidl_stats->iface.V1_0.wmeViPktStats.rxMpdu =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu;
+    hidl_stats->iface.V1_0.wmeViPktStats.txMpdu =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu;
+    hidl_stats->iface.V1_0.wmeViPktStats.lostMpdu =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost;
+    hidl_stats->iface.V1_0.wmeViPktStats.retries =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries;
+    hidl_stats->iface.wmeViContentionTimeStats.contentionTimeMinInUsec =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_min;
+    hidl_stats->iface.wmeViContentionTimeStats.contentionTimeMaxInUsec =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_max;
+    hidl_stats->iface.wmeViContentionTimeStats.contentionTimeAvgInUsec =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_avg;
+    hidl_stats->iface.wmeViContentionTimeStats.contentionNumSamples =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples;
+    hidl_stats->iface.V1_0.wmeVoPktStats.rxMpdu =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu;
+    hidl_stats->iface.V1_0.wmeVoPktStats.txMpdu =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu;
+    hidl_stats->iface.V1_0.wmeVoPktStats.lostMpdu =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost;
+    hidl_stats->iface.V1_0.wmeVoPktStats.retries =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries;
+    hidl_stats->iface.wmeVoContentionTimeStats.contentionTimeMinInUsec =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_min;
+    hidl_stats->iface.wmeVoContentionTimeStats.contentionTimeMaxInUsec =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_max;
+    hidl_stats->iface.wmeVoContentionTimeStats.contentionTimeAvgInUsec =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_avg;
+    hidl_stats->iface.wmeVoContentionTimeStats.contentionNumSamples =
+            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples;
+    hidl_stats->iface.timeSliceDutyCycleInPercent =
+            legacy_stats.iface.info.time_slicing_duty_cycle_percent;
+    // peer info legacy_stats conversion.
+    std::vector<V1_6::StaPeerInfo> hidl_peers_info_stats;
+    for (const auto& legacy_peer_info_stats : legacy_stats.peers) {
+        V1_6::StaPeerInfo hidl_peer_info_stats;
+        if (!convertLegacyPeerInfoStatsToHidl(legacy_peer_info_stats, &hidl_peer_info_stats)) {
+            return false;
+        }
+        hidl_peers_info_stats.push_back(hidl_peer_info_stats);
+    }
+    hidl_stats->iface.peers = hidl_peers_info_stats;
+    // radio legacy_stats conversion.
+    std::vector<V1_6::StaLinkLayerRadioStats> hidl_radios_stats;
+    for (const auto& legacy_radio_stats : legacy_stats.radios) {
+        V1_6::StaLinkLayerRadioStats hidl_radio_stats;
+        if (!convertLegacyLinkLayerRadioStatsToHidl(legacy_radio_stats, &hidl_radio_stats)) {
+            return false;
+        }
+        hidl_radios_stats.push_back(hidl_radio_stats);
+    }
+    hidl_stats->radios = hidl_radios_stats;
+    // Timestamp in the HAL wrapper here since it's not provided in the legacy
+    // HAL API.
+    hidl_stats->timeStampInMs = uptimeMillis();
+    return true;
+}
+
+bool convertLegacyPeerInfoStatsToHidl(const legacy_hal::WifiPeerInfo& legacy_peer_info_stats,
+                                      V1_6::StaPeerInfo* hidl_peer_info_stats) {
+    if (!hidl_peer_info_stats) {
+        return false;
+    }
+    *hidl_peer_info_stats = {};
+    hidl_peer_info_stats->staCount = legacy_peer_info_stats.peer_info.bssload.sta_count;
+    hidl_peer_info_stats->chanUtil = legacy_peer_info_stats.peer_info.bssload.chan_util;
+
+    std::vector<V1_6::StaRateStat> hidlRateStats;
+    for (const auto& legacy_rate_stats : legacy_peer_info_stats.rate_stats) {
+        V1_6::StaRateStat rateStat;
+        if (!convertLegacyWifiRateInfoToHidl(legacy_rate_stats.rate, &rateStat.rateInfo)) {
+            return false;
+        }
+        rateStat.txMpdu = legacy_rate_stats.tx_mpdu;
+        rateStat.rxMpdu = legacy_rate_stats.rx_mpdu;
+        rateStat.mpduLost = legacy_rate_stats.mpdu_lost;
+        rateStat.retries = legacy_rate_stats.retries;
+        hidlRateStats.push_back(rateStat);
+    }
+    hidl_peer_info_stats->rateStats = hidlRateStats;
+    return true;
+}
+
+bool convertLegacyRoamingCapabilitiesToHidl(
+        const legacy_hal::wifi_roaming_capabilities& legacy_caps,
+        StaRoamingCapabilities* hidl_caps) {
+    if (!hidl_caps) {
+        return false;
+    }
+    *hidl_caps = {};
+    hidl_caps->maxBlacklistSize = legacy_caps.max_blacklist_size;
+    hidl_caps->maxWhitelistSize = legacy_caps.max_whitelist_size;
+    return true;
+}
+
+bool convertHidlRoamingConfigToLegacy(const StaRoamingConfig& hidl_config,
+                                      legacy_hal::wifi_roaming_config* legacy_config) {
+    if (!legacy_config) {
+        return false;
+    }
+    *legacy_config = {};
+    if (hidl_config.bssidBlacklist.size() > MAX_BLACKLIST_BSSID ||
+        hidl_config.ssidWhitelist.size() > MAX_WHITELIST_SSID) {
+        return false;
+    }
+    legacy_config->num_blacklist_bssid = hidl_config.bssidBlacklist.size();
+    uint32_t i = 0;
+    for (const auto& bssid : hidl_config.bssidBlacklist) {
+        CHECK(bssid.size() == sizeof(legacy_hal::mac_addr));
+        memcpy(legacy_config->blacklist_bssid[i++], bssid.data(), bssid.size());
+    }
+    legacy_config->num_whitelist_ssid = hidl_config.ssidWhitelist.size();
+    i = 0;
+    for (const auto& ssid : hidl_config.ssidWhitelist) {
+        CHECK(ssid.size() <= sizeof(legacy_hal::ssid_t::ssid_str));
+        legacy_config->whitelist_ssid[i].length = ssid.size();
+        memcpy(legacy_config->whitelist_ssid[i].ssid_str, ssid.data(), ssid.size());
+        i++;
+    }
+    return true;
+}
+
+legacy_hal::fw_roaming_state_t convertHidlRoamingStateToLegacy(StaRoamingState state) {
+    switch (state) {
+        case StaRoamingState::ENABLED:
+            return legacy_hal::ROAMING_ENABLE;
+        case StaRoamingState::DISABLED:
+            return legacy_hal::ROAMING_DISABLE;
+    };
+    CHECK(false);
+}
+
+legacy_hal::NanMatchAlg convertHidlNanMatchAlgToLegacy(NanMatchAlg type) {
+    switch (type) {
+        case NanMatchAlg::MATCH_ONCE:
+            return legacy_hal::NAN_MATCH_ALG_MATCH_ONCE;
+        case NanMatchAlg::MATCH_CONTINUOUS:
+            return legacy_hal::NAN_MATCH_ALG_MATCH_CONTINUOUS;
+        case NanMatchAlg::MATCH_NEVER:
+            return legacy_hal::NAN_MATCH_ALG_MATCH_NEVER;
+    }
+    CHECK(false);
+}
+
+legacy_hal::NanPublishType convertHidlNanPublishTypeToLegacy(NanPublishType type) {
+    switch (type) {
+        case NanPublishType::UNSOLICITED:
+            return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED;
+        case NanPublishType::SOLICITED:
+            return legacy_hal::NAN_PUBLISH_TYPE_SOLICITED;
+        case NanPublishType::UNSOLICITED_SOLICITED:
+            return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
+    }
+    CHECK(false);
+}
+
+legacy_hal::NanTxType convertHidlNanTxTypeToLegacy(NanTxType type) {
+    switch (type) {
+        case NanTxType::BROADCAST:
+            return legacy_hal::NAN_TX_TYPE_BROADCAST;
+        case NanTxType::UNICAST:
+            return legacy_hal::NAN_TX_TYPE_UNICAST;
+    }
+    CHECK(false);
+}
+
+legacy_hal::NanSubscribeType convertHidlNanSubscribeTypeToLegacy(NanSubscribeType type) {
+    switch (type) {
+        case NanSubscribeType::PASSIVE:
+            return legacy_hal::NAN_SUBSCRIBE_TYPE_PASSIVE;
+        case NanSubscribeType::ACTIVE:
+            return legacy_hal::NAN_SUBSCRIBE_TYPE_ACTIVE;
+    }
+    CHECK(false);
+}
+
+legacy_hal::NanSRFType convertHidlNanSrfTypeToLegacy(NanSrfType type) {
+    switch (type) {
+        case NanSrfType::BLOOM_FILTER:
+            return legacy_hal::NAN_SRF_ATTR_BLOOM_FILTER;
+        case NanSrfType::PARTIAL_MAC_ADDR:
+            return legacy_hal::NAN_SRF_ATTR_PARTIAL_MAC_ADDR;
+    }
+    CHECK(false);
+}
+
+legacy_hal::NanDataPathChannelCfg convertHidlNanDataPathChannelCfgToLegacy(
+        NanDataPathChannelCfg type) {
+    switch (type) {
+        case NanDataPathChannelCfg::CHANNEL_NOT_REQUESTED:
+            return legacy_hal::NAN_DP_CHANNEL_NOT_REQUESTED;
+        case NanDataPathChannelCfg::REQUEST_CHANNEL_SETUP:
+            return legacy_hal::NAN_DP_REQUEST_CHANNEL_SETUP;
+        case NanDataPathChannelCfg::FORCE_CHANNEL_SETUP:
+            return legacy_hal::NAN_DP_FORCE_CHANNEL_SETUP;
+    }
+    CHECK(false);
+}
+
+NanStatusType convertLegacyNanStatusTypeToHidl(legacy_hal::NanStatusType type) {
+    switch (type) {
+        case legacy_hal::NAN_STATUS_SUCCESS:
+            return NanStatusType::SUCCESS;
+        case legacy_hal::NAN_STATUS_INTERNAL_FAILURE:
+            return NanStatusType::INTERNAL_FAILURE;
+        case legacy_hal::NAN_STATUS_PROTOCOL_FAILURE:
+            return NanStatusType::PROTOCOL_FAILURE;
+        case legacy_hal::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID:
+            return NanStatusType::INVALID_SESSION_ID;
+        case legacy_hal::NAN_STATUS_NO_RESOURCE_AVAILABLE:
+            return NanStatusType::NO_RESOURCES_AVAILABLE;
+        case legacy_hal::NAN_STATUS_INVALID_PARAM:
+            return NanStatusType::INVALID_ARGS;
+        case legacy_hal::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID:
+            return NanStatusType::INVALID_PEER_ID;
+        case legacy_hal::NAN_STATUS_INVALID_NDP_ID:
+            return NanStatusType::INVALID_NDP_ID;
+        case legacy_hal::NAN_STATUS_NAN_NOT_ALLOWED:
+            return NanStatusType::NAN_NOT_ALLOWED;
+        case legacy_hal::NAN_STATUS_NO_OTA_ACK:
+            return NanStatusType::NO_OTA_ACK;
+        case legacy_hal::NAN_STATUS_ALREADY_ENABLED:
+            return NanStatusType::ALREADY_ENABLED;
+        case legacy_hal::NAN_STATUS_FOLLOWUP_QUEUE_FULL:
+            return NanStatusType::FOLLOWUP_TX_QUEUE_FULL;
+        case legacy_hal::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED:
+            return NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED;
+    }
+    CHECK(false);
+}
+
+void convertToWifiNanStatus(legacy_hal::NanStatusType type, const char* str, size_t max_len,
+                            WifiNanStatus* wifiNanStatus) {
+    wifiNanStatus->status = convertLegacyNanStatusTypeToHidl(type);
+    wifiNanStatus->description = safeConvertChar(str, max_len);
+}
+
+bool convertHidlNanEnableRequestToLegacy(const V1_4::NanEnableRequest& hidl_request,
+                                         legacy_hal::NanEnableRequest* legacy_request) {
+    if (!legacy_request) {
+        LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: null legacy_request";
+        return false;
+    }
+    *legacy_request = {};
+
+    legacy_request->config_2dot4g_support = 1;
+    legacy_request->support_2dot4g_val =
+            hidl_request.operateInBand[(size_t)NanBandIndex::NAN_BAND_24GHZ];
+    legacy_request->config_support_5g = 1;
+    legacy_request->support_5g_val =
+            hidl_request.operateInBand[(size_t)NanBandIndex::NAN_BAND_5GHZ];
+    legacy_request->config_hop_count_limit = 1;
+    legacy_request->hop_count_limit_val = hidl_request.hopCountMax;
+    legacy_request->master_pref = hidl_request.configParams.masterPref;
+    legacy_request->discovery_indication_cfg = 0;
+    legacy_request->discovery_indication_cfg |=
+            hidl_request.configParams.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
+    legacy_request->discovery_indication_cfg |=
+            hidl_request.configParams.disableStartedClusterIndication ? 0x2 : 0x0;
+    legacy_request->discovery_indication_cfg |=
+            hidl_request.configParams.disableJoinedClusterIndication ? 0x4 : 0x0;
+    legacy_request->config_sid_beacon = 1;
+    if (hidl_request.configParams.numberOfPublishServiceIdsInBeacon > 127) {
+        LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
+                      "numberOfPublishServiceIdsInBeacon > 127";
+        return false;
+    }
+    legacy_request->sid_beacon_val =
+            (hidl_request.configParams.includePublishServiceIdsInBeacon ? 0x1 : 0x0) |
+            (hidl_request.configParams.numberOfPublishServiceIdsInBeacon << 1);
+    legacy_request->config_subscribe_sid_beacon = 1;
+    if (hidl_request.configParams.numberOfSubscribeServiceIdsInBeacon > 127) {
+        LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
+                      "numberOfSubscribeServiceIdsInBeacon > 127";
+        return false;
+    }
+    legacy_request->subscribe_sid_beacon_val =
+            (hidl_request.configParams.includeSubscribeServiceIdsInBeacon ? 0x1 : 0x0) |
+            (hidl_request.configParams.numberOfSubscribeServiceIdsInBeacon << 1);
+    legacy_request->config_rssi_window_size = 1;
+    legacy_request->rssi_window_size_val = hidl_request.configParams.rssiWindowSize;
+    legacy_request->config_disc_mac_addr_randomization = 1;
+    legacy_request->disc_mac_addr_rand_interval_sec =
+            hidl_request.configParams.macAddressRandomizationIntervalSec;
+    legacy_request->config_2dot4g_rssi_close = 1;
+    if (hidl_request.configParams.bandSpecificConfig.size() != 3) {
+        LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
+                      "bandSpecificConfig.size() != 3";
+        return false;
+    }
+    legacy_request->rssi_close_2dot4g_val =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
+                    .rssiClose;
+    legacy_request->config_2dot4g_rssi_middle = 1;
+    legacy_request->rssi_middle_2dot4g_val =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
+                    .rssiMiddle;
+    legacy_request->config_2dot4g_rssi_proximity = 1;
+    legacy_request->rssi_proximity_2dot4g_val =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
+                    .rssiCloseProximity;
+    legacy_request->config_scan_params = 1;
+    legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
+                    .dwellTimeMs;
+    legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
+                    .scanPeriodSec;
+    legacy_request->config_dw.config_2dot4g_dw_band =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
+                    .validDiscoveryWindowIntervalVal;
+    legacy_request->config_dw.dw_2dot4g_interval_val =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
+                    .discoveryWindowIntervalVal;
+    legacy_request->config_5g_rssi_close = 1;
+    legacy_request->rssi_close_5g_val =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
+                    .rssiClose;
+    legacy_request->config_5g_rssi_middle = 1;
+    legacy_request->rssi_middle_5g_val =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
+                    .rssiMiddle;
+    legacy_request->config_5g_rssi_close_proximity = 1;
+    legacy_request->rssi_close_proximity_5g_val =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
+                    .rssiCloseProximity;
+    legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
+                    .dwellTimeMs;
+    legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
+                    .scanPeriodSec;
+    legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
+                    .dwellTimeMs;
+    legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
+                    .scanPeriodSec;
+    legacy_request->config_dw.config_5g_dw_band =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
+                    .validDiscoveryWindowIntervalVal;
+    legacy_request->config_dw.dw_5g_interval_val =
+            hidl_request.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
+                    .discoveryWindowIntervalVal;
+    if (hidl_request.debugConfigs.validClusterIdVals) {
+        legacy_request->cluster_low = hidl_request.debugConfigs.clusterIdBottomRangeVal;
+        legacy_request->cluster_high = hidl_request.debugConfigs.clusterIdTopRangeVal;
+    } else {  // need 'else' since not configurable in legacy HAL
+        legacy_request->cluster_low = 0x0000;
+        legacy_request->cluster_high = 0xFFFF;
+    }
+    legacy_request->config_intf_addr = hidl_request.debugConfigs.validIntfAddrVal;
+    memcpy(legacy_request->intf_addr_val, hidl_request.debugConfigs.intfAddrVal.data(), 6);
+    legacy_request->config_oui = hidl_request.debugConfigs.validOuiVal;
+    legacy_request->oui_val = hidl_request.debugConfigs.ouiVal;
+    legacy_request->config_random_factor_force =
+            hidl_request.debugConfigs.validRandomFactorForceVal;
+    legacy_request->random_factor_force_val = hidl_request.debugConfigs.randomFactorForceVal;
+    legacy_request->config_hop_count_force = hidl_request.debugConfigs.validHopCountForceVal;
+    legacy_request->hop_count_force_val = hidl_request.debugConfigs.hopCountForceVal;
+    legacy_request->config_24g_channel = hidl_request.debugConfigs.validDiscoveryChannelVal;
+    legacy_request->channel_24g_val =
+            hidl_request.debugConfigs.discoveryChannelMhzVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
+    legacy_request->config_5g_channel = hidl_request.debugConfigs.validDiscoveryChannelVal;
+    legacy_request->channel_5g_val =
+            hidl_request.debugConfigs.discoveryChannelMhzVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
+    legacy_request->config_2dot4g_beacons = hidl_request.debugConfigs.validUseBeaconsInBandVal;
+    legacy_request->beacon_2dot4g_val =
+            hidl_request.debugConfigs.useBeaconsInBandVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
+    legacy_request->config_5g_beacons = hidl_request.debugConfigs.validUseBeaconsInBandVal;
+    legacy_request->beacon_5g_val =
+            hidl_request.debugConfigs.useBeaconsInBandVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
+    legacy_request->config_2dot4g_sdf = hidl_request.debugConfigs.validUseSdfInBandVal;
+    legacy_request->sdf_2dot4g_val =
+            hidl_request.debugConfigs.useSdfInBandVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
+    legacy_request->config_5g_sdf = hidl_request.debugConfigs.validUseSdfInBandVal;
+    legacy_request->sdf_5g_val =
+            hidl_request.debugConfigs.useSdfInBandVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
+
+    /* TODO: b/145609058
+     * Missing updates needed to legacy_hal::NanEnableRequest and conversion to
+     * it for 6GHz band */
+
+    return true;
+}
+
+bool convertHidlNanEnableRequest_1_6ToLegacy(const V1_4::NanEnableRequest& hidl_request1,
+                                             const NanConfigRequestSupplemental& hidl_request2,
+                                             legacy_hal::NanEnableRequest* legacy_request) {
+    if (!legacy_request) {
+        LOG(ERROR) << "convertHidlNanEnableRequest_1_6ToLegacy: null legacy_request";
+        return false;
+    }
+
+    *legacy_request = {};
+    if (!convertHidlNanEnableRequestToLegacy(hidl_request1, legacy_request)) {
+        return false;
+    }
+
+    legacy_request->config_discovery_beacon_int = 1;
+    legacy_request->discovery_beacon_interval = hidl_request2.V1_5.V1_2.discoveryBeaconIntervalMs;
+    legacy_request->config_nss = 1;
+    legacy_request->nss = hidl_request2.V1_5.V1_2.numberOfSpatialStreamsInDiscovery;
+    legacy_request->config_dw_early_termination = 1;
+    legacy_request->enable_dw_termination =
+            hidl_request2.V1_5.V1_2.enableDiscoveryWindowEarlyTermination;
+    legacy_request->config_enable_ranging = 1;
+    legacy_request->enable_ranging = hidl_request2.V1_5.V1_2.enableRanging;
+
+    legacy_request->config_enable_instant_mode = 1;
+    legacy_request->enable_instant_mode = hidl_request2.V1_5.enableInstantCommunicationMode;
+    legacy_request->config_instant_mode_channel = 1;
+    legacy_request->instant_mode_channel = hidl_request2.instantModeChannel;
+
+    return true;
+}
+
+bool convertHidlNanConfigRequest_1_6ToLegacy(const V1_4::NanConfigRequest& hidl_request1,
+                                             const NanConfigRequestSupplemental& hidl_request2,
+                                             legacy_hal::NanConfigRequest* legacy_request) {
+    if (!legacy_request) {
+        LOG(ERROR) << "convertHidlNanConfigRequest_1_6ToLegacy: null legacy_request";
+        return false;
+    }
+
+    *legacy_request = {};
+    if (!convertHidlNanConfigRequestToLegacy(hidl_request1, legacy_request)) {
+        return false;
+    }
+
+    legacy_request->config_discovery_beacon_int = 1;
+    legacy_request->discovery_beacon_interval = hidl_request2.V1_5.V1_2.discoveryBeaconIntervalMs;
+    legacy_request->config_nss = 1;
+    legacy_request->nss = hidl_request2.V1_5.V1_2.numberOfSpatialStreamsInDiscovery;
+    legacy_request->config_dw_early_termination = 1;
+    legacy_request->enable_dw_termination =
+            hidl_request2.V1_5.V1_2.enableDiscoveryWindowEarlyTermination;
+    legacy_request->config_enable_ranging = 1;
+    legacy_request->enable_ranging = hidl_request2.V1_5.V1_2.enableRanging;
+
+    legacy_request->config_enable_instant_mode = 1;
+    legacy_request->enable_instant_mode = hidl_request2.V1_5.enableInstantCommunicationMode;
+    legacy_request->config_instant_mode_channel = 1;
+    legacy_request->instant_mode_channel = hidl_request2.instantModeChannel;
+
+    return true;
+}
+
+bool convertHidlNanPublishRequestToLegacy(const V1_6::NanPublishRequest& hidl_request,
+                                          legacy_hal::NanPublishRequest* legacy_request) {
+    if (!legacy_request) {
+        LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: null legacy_request";
+        return false;
+    }
+    *legacy_request = {};
+
+    legacy_request->publish_id = hidl_request.baseConfigs.sessionId;
+    legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
+    legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
+    legacy_request->publish_count = hidl_request.baseConfigs.discoveryCount;
+    legacy_request->service_name_len = hidl_request.baseConfigs.serviceName.size();
+    if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
+        LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: service_name_len "
+                      "too large";
+        return false;
+    }
+    memcpy(legacy_request->service_name, hidl_request.baseConfigs.serviceName.data(),
+           legacy_request->service_name_len);
+    legacy_request->publish_match_indicator =
+            convertHidlNanMatchAlgToLegacy(hidl_request.baseConfigs.discoveryMatchIndicator);
+    legacy_request->service_specific_info_len = hidl_request.baseConfigs.serviceSpecificInfo.size();
+    if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
+        LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
+                      "service_specific_info_len too large";
+        return false;
+    }
+    memcpy(legacy_request->service_specific_info,
+           hidl_request.baseConfigs.serviceSpecificInfo.data(),
+           legacy_request->service_specific_info_len);
+    legacy_request->sdea_service_specific_info_len =
+            hidl_request.baseConfigs.extendedServiceSpecificInfo.size();
+    if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
+        LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
+                      "sdea_service_specific_info_len too large";
+        return false;
+    }
+    memcpy(legacy_request->sdea_service_specific_info,
+           hidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
+           legacy_request->sdea_service_specific_info_len);
+    legacy_request->rx_match_filter_len = hidl_request.baseConfigs.rxMatchFilter.size();
+    if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
+        LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
+                      "rx_match_filter_len too large";
+        return false;
+    }
+    memcpy(legacy_request->rx_match_filter, hidl_request.baseConfigs.rxMatchFilter.data(),
+           legacy_request->rx_match_filter_len);
+    legacy_request->tx_match_filter_len = hidl_request.baseConfigs.txMatchFilter.size();
+    if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
+        LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
+                      "tx_match_filter_len too large";
+        return false;
+    }
+    memcpy(legacy_request->tx_match_filter, hidl_request.baseConfigs.txMatchFilter.data(),
+           legacy_request->tx_match_filter_len);
+    legacy_request->rssi_threshold_flag = hidl_request.baseConfigs.useRssiThreshold;
+    legacy_request->recv_indication_cfg = 0;
+    legacy_request->recv_indication_cfg |=
+            hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1 : 0x0;
+    legacy_request->recv_indication_cfg |=
+            hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
+    legacy_request->recv_indication_cfg |=
+            hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
+    legacy_request->recv_indication_cfg |= 0x8;
+    legacy_request->cipher_type = (unsigned int)hidl_request.baseConfigs.securityConfig.cipherType;
+
+    legacy_request->scid_len = hidl_request.baseConfigs.securityConfig.scid.size();
+    if (legacy_request->scid_len > NAN_MAX_SCID_BUF_LEN) {
+        LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: scid_len too large";
+        return false;
+    }
+    memcpy(legacy_request->scid, hidl_request.baseConfigs.securityConfig.scid.data(),
+           legacy_request->scid_len);
+
+    if (hidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PMK) {
+        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
+        legacy_request->key_info.body.pmk_info.pmk_len =
+                hidl_request.baseConfigs.securityConfig.pmk.size();
+        if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
+            LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: invalid pmk_len";
+            return false;
+        }
+        memcpy(legacy_request->key_info.body.pmk_info.pmk,
+               hidl_request.baseConfigs.securityConfig.pmk.data(),
+               legacy_request->key_info.body.pmk_info.pmk_len);
+    }
+    if (hidl_request.baseConfigs.securityConfig.securityType ==
+        NanDataPathSecurityType::PASSPHRASE) {
+        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
+        legacy_request->key_info.body.passphrase_info.passphrase_len =
+                hidl_request.baseConfigs.securityConfig.passphrase.size();
+        if (legacy_request->key_info.body.passphrase_info.passphrase_len <
+            NAN_SECURITY_MIN_PASSPHRASE_LEN) {
+            LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
+                          "passphrase_len too small";
+            return false;
+        }
+        if (legacy_request->key_info.body.passphrase_info.passphrase_len >
+            NAN_SECURITY_MAX_PASSPHRASE_LEN) {
+            LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
+                          "passphrase_len too large";
+            return false;
+        }
+        memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
+               hidl_request.baseConfigs.securityConfig.passphrase.data(),
+               legacy_request->key_info.body.passphrase_info.passphrase_len);
+    }
+    legacy_request->sdea_params.security_cfg =
+            (hidl_request.baseConfigs.securityConfig.securityType != NanDataPathSecurityType::OPEN)
+                    ? legacy_hal::NAN_DP_CONFIG_SECURITY
+                    : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
+
+    legacy_request->sdea_params.ranging_state = hidl_request.baseConfigs.rangingRequired
+                                                        ? legacy_hal::NAN_RANGING_ENABLE
+                                                        : legacy_hal::NAN_RANGING_DISABLE;
+    legacy_request->ranging_cfg.ranging_interval_msec =
+            hidl_request.baseConfigs.rangingIntervalMsec;
+    legacy_request->ranging_cfg.config_ranging_indications =
+            hidl_request.baseConfigs.configRangingIndications;
+    legacy_request->ranging_cfg.distance_ingress_mm =
+            hidl_request.baseConfigs.distanceIngressCm * 10;
+    legacy_request->ranging_cfg.distance_egress_mm = hidl_request.baseConfigs.distanceEgressCm * 10;
+    legacy_request->ranging_auto_response = hidl_request.baseConfigs.rangingRequired
+                                                    ? legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE
+                                                    : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
+    legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT;
+    legacy_request->publish_type = convertHidlNanPublishTypeToLegacy(hidl_request.publishType);
+    legacy_request->tx_type = convertHidlNanTxTypeToLegacy(hidl_request.txType);
+    legacy_request->service_responder_policy = hidl_request.autoAcceptDataPathRequests
+                                                       ? legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL
+                                                       : legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE;
+
+    return true;
+}
+
+bool convertHidlNanSubscribeRequestToLegacy(const V1_0::NanSubscribeRequest& hidl_request,
+                                            legacy_hal::NanSubscribeRequest* legacy_request) {
+    if (!legacy_request) {
+        LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: legacy_request is null";
+        return false;
+    }
+    *legacy_request = {};
+
+    legacy_request->subscribe_id = hidl_request.baseConfigs.sessionId;
+    legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
+    legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
+    legacy_request->subscribe_count = hidl_request.baseConfigs.discoveryCount;
+    legacy_request->service_name_len = hidl_request.baseConfigs.serviceName.size();
+    if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
+        LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
+                      "service_name_len too large";
+        return false;
+    }
+    memcpy(legacy_request->service_name, hidl_request.baseConfigs.serviceName.data(),
+           legacy_request->service_name_len);
+    legacy_request->subscribe_match_indicator =
+            convertHidlNanMatchAlgToLegacy(hidl_request.baseConfigs.discoveryMatchIndicator);
+    legacy_request->service_specific_info_len = hidl_request.baseConfigs.serviceSpecificInfo.size();
+    if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
+        LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
+                      "service_specific_info_len too large";
+        return false;
+    }
+    memcpy(legacy_request->service_specific_info,
+           hidl_request.baseConfigs.serviceSpecificInfo.data(),
+           legacy_request->service_specific_info_len);
+    legacy_request->sdea_service_specific_info_len =
+            hidl_request.baseConfigs.extendedServiceSpecificInfo.size();
+    if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
+        LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
+                      "sdea_service_specific_info_len too large";
+        return false;
+    }
+    memcpy(legacy_request->sdea_service_specific_info,
+           hidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
+           legacy_request->sdea_service_specific_info_len);
+    legacy_request->rx_match_filter_len = hidl_request.baseConfigs.rxMatchFilter.size();
+    if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
+        LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
+                      "rx_match_filter_len too large";
+        return false;
+    }
+    memcpy(legacy_request->rx_match_filter, hidl_request.baseConfigs.rxMatchFilter.data(),
+           legacy_request->rx_match_filter_len);
+    legacy_request->tx_match_filter_len = hidl_request.baseConfigs.txMatchFilter.size();
+    if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
+        LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
+                      "tx_match_filter_len too large";
+        return false;
+    }
+    memcpy(legacy_request->tx_match_filter, hidl_request.baseConfigs.txMatchFilter.data(),
+           legacy_request->tx_match_filter_len);
+    legacy_request->rssi_threshold_flag = hidl_request.baseConfigs.useRssiThreshold;
+    legacy_request->recv_indication_cfg = 0;
+    legacy_request->recv_indication_cfg |=
+            hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1 : 0x0;
+    legacy_request->recv_indication_cfg |=
+            hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
+    legacy_request->recv_indication_cfg |=
+            hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
+    legacy_request->cipher_type = (unsigned int)hidl_request.baseConfigs.securityConfig.cipherType;
+    if (hidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PMK) {
+        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
+        legacy_request->key_info.body.pmk_info.pmk_len =
+                hidl_request.baseConfigs.securityConfig.pmk.size();
+        if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
+            LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: invalid pmk_len";
+            return false;
+        }
+        memcpy(legacy_request->key_info.body.pmk_info.pmk,
+               hidl_request.baseConfigs.securityConfig.pmk.data(),
+               legacy_request->key_info.body.pmk_info.pmk_len);
+    }
+    if (hidl_request.baseConfigs.securityConfig.securityType ==
+        NanDataPathSecurityType::PASSPHRASE) {
+        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
+        legacy_request->key_info.body.passphrase_info.passphrase_len =
+                hidl_request.baseConfigs.securityConfig.passphrase.size();
+        if (legacy_request->key_info.body.passphrase_info.passphrase_len <
+            NAN_SECURITY_MIN_PASSPHRASE_LEN) {
+            LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
+                          "passphrase_len too small";
+            return false;
+        }
+        if (legacy_request->key_info.body.passphrase_info.passphrase_len >
+            NAN_SECURITY_MAX_PASSPHRASE_LEN) {
+            LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
+                          "passphrase_len too large";
+            return false;
+        }
+        memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
+               hidl_request.baseConfigs.securityConfig.passphrase.data(),
+               legacy_request->key_info.body.passphrase_info.passphrase_len);
+    }
+    legacy_request->sdea_params.security_cfg =
+            (hidl_request.baseConfigs.securityConfig.securityType != NanDataPathSecurityType::OPEN)
+                    ? legacy_hal::NAN_DP_CONFIG_SECURITY
+                    : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
+    legacy_request->sdea_params.ranging_state = hidl_request.baseConfigs.rangingRequired
+                                                        ? legacy_hal::NAN_RANGING_ENABLE
+                                                        : legacy_hal::NAN_RANGING_DISABLE;
+    legacy_request->ranging_cfg.ranging_interval_msec =
+            hidl_request.baseConfigs.rangingIntervalMsec;
+    legacy_request->ranging_cfg.config_ranging_indications =
+            hidl_request.baseConfigs.configRangingIndications;
+    legacy_request->ranging_cfg.distance_ingress_mm =
+            hidl_request.baseConfigs.distanceIngressCm * 10;
+    legacy_request->ranging_cfg.distance_egress_mm = hidl_request.baseConfigs.distanceEgressCm * 10;
+    legacy_request->ranging_auto_response = hidl_request.baseConfigs.rangingRequired
+                                                    ? legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE
+                                                    : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
+    legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT;
+    legacy_request->subscribe_type =
+            convertHidlNanSubscribeTypeToLegacy(hidl_request.subscribeType);
+    legacy_request->serviceResponseFilter = convertHidlNanSrfTypeToLegacy(hidl_request.srfType);
+    legacy_request->serviceResponseInclude = hidl_request.srfRespondIfInAddressSet
+                                                     ? legacy_hal::NAN_SRF_INCLUDE_RESPOND
+                                                     : legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
+    legacy_request->useServiceResponseFilter =
+            hidl_request.shouldUseSrf ? legacy_hal::NAN_USE_SRF : legacy_hal::NAN_DO_NOT_USE_SRF;
+    legacy_request->ssiRequiredForMatchIndication =
+            hidl_request.isSsiRequiredForMatch ? legacy_hal::NAN_SSI_REQUIRED_IN_MATCH_IND
+                                               : legacy_hal::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND;
+    legacy_request->num_intf_addr_present = hidl_request.intfAddr.size();
+    if (legacy_request->num_intf_addr_present > NAN_MAX_SUBSCRIBE_MAX_ADDRESS) {
+        LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
+                      "num_intf_addr_present - too many";
+        return false;
+    }
+    for (int i = 0; i < legacy_request->num_intf_addr_present; i++) {
+        memcpy(legacy_request->intf_addr[i], hidl_request.intfAddr[i].data(), 6);
+    }
+
+    return true;
+}
+
+bool convertHidlNanTransmitFollowupRequestToLegacy(
+        const NanTransmitFollowupRequest& hidl_request,
+        legacy_hal::NanTransmitFollowupRequest* legacy_request) {
+    if (!legacy_request) {
+        LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
+                      "legacy_request is null";
+        return false;
+    }
+    *legacy_request = {};
+
+    legacy_request->publish_subscribe_id = hidl_request.discoverySessionId;
+    legacy_request->requestor_instance_id = hidl_request.peerId;
+    memcpy(legacy_request->addr, hidl_request.addr.data(), 6);
+    legacy_request->priority = hidl_request.isHighPriority ? legacy_hal::NAN_TX_PRIORITY_HIGH
+                                                           : legacy_hal::NAN_TX_PRIORITY_NORMAL;
+    legacy_request->dw_or_faw = hidl_request.shouldUseDiscoveryWindow
+                                        ? legacy_hal::NAN_TRANSMIT_IN_DW
+                                        : legacy_hal::NAN_TRANSMIT_IN_FAW;
+    legacy_request->service_specific_info_len = hidl_request.serviceSpecificInfo.size();
+    if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
+        LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
+                      "service_specific_info_len too large";
+        return false;
+    }
+    memcpy(legacy_request->service_specific_info, hidl_request.serviceSpecificInfo.data(),
+           legacy_request->service_specific_info_len);
+    legacy_request->sdea_service_specific_info_len =
+            hidl_request.extendedServiceSpecificInfo.size();
+    if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
+        LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
+                      "sdea_service_specific_info_len too large";
+        return false;
+    }
+    memcpy(legacy_request->sdea_service_specific_info,
+           hidl_request.extendedServiceSpecificInfo.data(),
+           legacy_request->sdea_service_specific_info_len);
+    legacy_request->recv_indication_cfg = hidl_request.disableFollowupResultIndication ? 0x1 : 0x0;
+
+    return true;
+}
+
+bool convertHidlNanConfigRequestToLegacy(const V1_4::NanConfigRequest& hidl_request,
+                                         legacy_hal::NanConfigRequest* legacy_request) {
+    if (!legacy_request) {
+        LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: legacy_request is null";
+        return false;
+    }
+    *legacy_request = {};
+
+    // TODO: b/34059183 tracks missing configurations in legacy HAL or uknown
+    // defaults
+    legacy_request->master_pref = hidl_request.masterPref;
+    legacy_request->discovery_indication_cfg = 0;
+    legacy_request->discovery_indication_cfg |=
+            hidl_request.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
+    legacy_request->discovery_indication_cfg |=
+            hidl_request.disableStartedClusterIndication ? 0x2 : 0x0;
+    legacy_request->discovery_indication_cfg |=
+            hidl_request.disableJoinedClusterIndication ? 0x4 : 0x0;
+    legacy_request->config_sid_beacon = 1;
+    if (hidl_request.numberOfPublishServiceIdsInBeacon > 127) {
+        LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: "
+                      "numberOfPublishServiceIdsInBeacon > 127";
+        return false;
+    }
+    legacy_request->sid_beacon = (hidl_request.includePublishServiceIdsInBeacon ? 0x1 : 0x0) |
+                                 (hidl_request.numberOfPublishServiceIdsInBeacon << 1);
+    legacy_request->config_subscribe_sid_beacon = 1;
+    if (hidl_request.numberOfSubscribeServiceIdsInBeacon > 127) {
+        LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: "
+                      "numberOfSubscribeServiceIdsInBeacon > 127";
+        return false;
+    }
+    legacy_request->subscribe_sid_beacon_val =
+            (hidl_request.includeSubscribeServiceIdsInBeacon ? 0x1 : 0x0) |
+            (hidl_request.numberOfSubscribeServiceIdsInBeacon << 1);
+    legacy_request->config_rssi_window_size = 1;
+    legacy_request->rssi_window_size_val = hidl_request.rssiWindowSize;
+    legacy_request->config_disc_mac_addr_randomization = 1;
+    legacy_request->disc_mac_addr_rand_interval_sec =
+            hidl_request.macAddressRandomizationIntervalSec;
+    /* TODO : missing
+    legacy_request->config_2dot4g_rssi_close = 1;
+    legacy_request->rssi_close_2dot4g_val =
+          hidl_request.bandSpecificConfig[
+              (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiClose;
+    legacy_request->config_2dot4g_rssi_middle = 1;
+    legacy_request->rssi_middle_2dot4g_val =
+          hidl_request.bandSpecificConfig[
+              (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiMiddle;
+    legacy_request->config_2dot4g_rssi_proximity = 1;
+    legacy_request->rssi_proximity_2dot4g_val =
+          hidl_request.bandSpecificConfig[
+              (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiCloseProximity;
+    */
+    legacy_request->config_scan_params = 1;
+    legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
+            hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ].dwellTimeMs;
+    legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
+            hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ].scanPeriodSec;
+    legacy_request->config_dw.config_2dot4g_dw_band =
+            hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
+                    .validDiscoveryWindowIntervalVal;
+    legacy_request->config_dw.dw_2dot4g_interval_val =
+            hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
+                    .discoveryWindowIntervalVal;
+    /* TODO: missing
+    legacy_request->config_5g_rssi_close = 1;
+    legacy_request->rssi_close_5g_val =
+          hidl_request.bandSpecificConfig[
+              (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiClose;
+    legacy_request->config_5g_rssi_middle = 1;
+    legacy_request->rssi_middle_5g_val =
+          hidl_request.bandSpecificConfig[
+              (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiMiddle;
+    */
+    legacy_request->config_5g_rssi_close_proximity = 1;
+    legacy_request->rssi_close_proximity_5g_val =
+            hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ].rssiCloseProximity;
+    legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
+            hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
+    legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
+            hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
+    legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
+            hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
+    legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
+            hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
+    legacy_request->config_dw.config_5g_dw_band =
+            hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
+                    .validDiscoveryWindowIntervalVal;
+    legacy_request->config_dw.dw_5g_interval_val =
+            hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
+                    .discoveryWindowIntervalVal;
+    /* TODO: b/145609058
+     * Missing updates needed to legacy_hal::NanConfigRequest and conversion to
+     * it for 6GHz band */
+
+    return true;
+}
+
+bool convertHidlNanDataPathInitiatorRequestToLegacy(
+        const V1_0::NanInitiateDataPathRequest& hidl_request,
+        legacy_hal::NanDataPathInitiatorRequest* legacy_request) {
+    if (!legacy_request) {
+        LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
+                      "legacy_request is null";
+        return false;
+    }
+    *legacy_request = {};
+
+    legacy_request->requestor_instance_id = hidl_request.peerId;
+    memcpy(legacy_request->peer_disc_mac_addr, hidl_request.peerDiscMacAddr.data(), 6);
+    legacy_request->channel_request_type =
+            convertHidlNanDataPathChannelCfgToLegacy(hidl_request.channelRequestType);
+    legacy_request->channel = hidl_request.channel;
+    if (strnlen(hidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
+        LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
+                      "ifaceName too long";
+        return false;
+    }
+    strlcpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str(), IFNAMSIZ + 1);
+    legacy_request->ndp_cfg.security_cfg =
+            (hidl_request.securityConfig.securityType != NanDataPathSecurityType::OPEN)
+                    ? legacy_hal::NAN_DP_CONFIG_SECURITY
+                    : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
+    legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
+    if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
+        LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
+                      "ndp_app_info_len too large";
+        return false;
+    }
+    memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
+           legacy_request->app_info.ndp_app_info_len);
+    legacy_request->cipher_type = (unsigned int)hidl_request.securityConfig.cipherType;
+    if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PMK) {
+        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
+        legacy_request->key_info.body.pmk_info.pmk_len = hidl_request.securityConfig.pmk.size();
+        if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
+            LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
+                          "invalid pmk_len";
+            return false;
+        }
+        memcpy(legacy_request->key_info.body.pmk_info.pmk, hidl_request.securityConfig.pmk.data(),
+               legacy_request->key_info.body.pmk_info.pmk_len);
+    }
+    if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) {
+        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
+        legacy_request->key_info.body.passphrase_info.passphrase_len =
+                hidl_request.securityConfig.passphrase.size();
+        if (legacy_request->key_info.body.passphrase_info.passphrase_len <
+            NAN_SECURITY_MIN_PASSPHRASE_LEN) {
+            LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
+                          "passphrase_len too small";
+            return false;
+        }
+        if (legacy_request->key_info.body.passphrase_info.passphrase_len >
+            NAN_SECURITY_MAX_PASSPHRASE_LEN) {
+            LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
+                          "passphrase_len too large";
+            return false;
+        }
+        memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
+               hidl_request.securityConfig.passphrase.data(),
+               legacy_request->key_info.body.passphrase_info.passphrase_len);
+    }
+    legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
+    if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
+        LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
+                      "service_name_len too large";
+        return false;
+    }
+    memcpy(legacy_request->service_name, hidl_request.serviceNameOutOfBand.data(),
+           legacy_request->service_name_len);
+
+    return true;
+}
+
+bool convertHidlNanDataPathInitiatorRequest_1_6ToLegacy(
+        const V1_6::NanInitiateDataPathRequest& hidl_request,
+        legacy_hal::NanDataPathInitiatorRequest* legacy_request) {
+    if (!legacy_request) {
+        LOG(ERROR) << "convertHidlNanDataPathInitiatorRequest_1_6ToLegacy: "
+                      "legacy_request is null";
+        return false;
+    }
+    *legacy_request = {};
+
+    legacy_request->requestor_instance_id = hidl_request.peerId;
+    memcpy(legacy_request->peer_disc_mac_addr, hidl_request.peerDiscMacAddr.data(), 6);
+    legacy_request->channel_request_type =
+            convertHidlNanDataPathChannelCfgToLegacy(hidl_request.channelRequestType);
+    legacy_request->channel = hidl_request.channel;
+    if (strnlen(hidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
+        LOG(ERROR) << "convertHidlNanDataPathInitiatorRequest_1_6ToLegacy: "
+                      "ifaceName too long";
+        return false;
+    }
+    strlcpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str(), IFNAMSIZ + 1);
+    legacy_request->ndp_cfg.security_cfg =
+            (hidl_request.securityConfig.securityType != NanDataPathSecurityType::OPEN)
+                    ? legacy_hal::NAN_DP_CONFIG_SECURITY
+                    : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
+    legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
+    if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
+        LOG(ERROR) << "convertHidlNanDataPathInitiatorRequest_1_6ToLegacy: "
+                      "ndp_app_info_len too large";
+        return false;
+    }
+    memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
+           legacy_request->app_info.ndp_app_info_len);
+    legacy_request->cipher_type = (unsigned int)hidl_request.securityConfig.cipherType;
+    if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PMK) {
+        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
+        legacy_request->key_info.body.pmk_info.pmk_len = hidl_request.securityConfig.pmk.size();
+        if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
+            LOG(ERROR) << "convertHidlNanDataPathInitiatorRequest_1_6ToLegacy: "
+                          "invalid pmk_len";
+            return false;
+        }
+        memcpy(legacy_request->key_info.body.pmk_info.pmk, hidl_request.securityConfig.pmk.data(),
+               legacy_request->key_info.body.pmk_info.pmk_len);
+    }
+    if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) {
+        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
+        legacy_request->key_info.body.passphrase_info.passphrase_len =
+                hidl_request.securityConfig.passphrase.size();
+        if (legacy_request->key_info.body.passphrase_info.passphrase_len <
+            NAN_SECURITY_MIN_PASSPHRASE_LEN) {
+            LOG(ERROR) << "convertHidlNanDataPathInitiatorRequest_1_6ToLegacy: "
+                          "passphrase_len too small";
+            return false;
+        }
+        if (legacy_request->key_info.body.passphrase_info.passphrase_len >
+            NAN_SECURITY_MAX_PASSPHRASE_LEN) {
+            LOG(ERROR) << "convertHidlNanDataPathInitiatorRequest_1_6ToLegacy: "
+                          "passphrase_len too large";
+            return false;
+        }
+        memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
+               hidl_request.securityConfig.passphrase.data(),
+               legacy_request->key_info.body.passphrase_info.passphrase_len);
+    }
+    legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
+    if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
+        LOG(ERROR) << "convertHidlNanDataPathInitiatorRequest_1_6ToLegacy: "
+                      "service_name_len too large";
+        return false;
+    }
+    memcpy(legacy_request->service_name, hidl_request.serviceNameOutOfBand.data(),
+           legacy_request->service_name_len);
+    legacy_request->scid_len = hidl_request.securityConfig.scid.size();
+    if (legacy_request->scid_len > NAN_MAX_SCID_BUF_LEN) {
+        LOG(ERROR) << "convertHidlNanDataPathInitiatorRequest_1_6ToLegacy: scid_len too large";
+        return false;
+    }
+    memcpy(legacy_request->scid, hidl_request.securityConfig.scid.data(), legacy_request->scid_len);
+
+    return true;
+}
+
+bool convertHidlNanDataPathIndicationResponseToLegacy(
+        const V1_0::NanRespondToDataPathIndicationRequest& hidl_request,
+        legacy_hal::NanDataPathIndicationResponse* legacy_request) {
+    if (!legacy_request) {
+        LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
+                      "legacy_request is null";
+        return false;
+    }
+    *legacy_request = {};
+
+    legacy_request->rsp_code = hidl_request.acceptRequest ? legacy_hal::NAN_DP_REQUEST_ACCEPT
+                                                          : legacy_hal::NAN_DP_REQUEST_REJECT;
+    legacy_request->ndp_instance_id = hidl_request.ndpInstanceId;
+    if (strnlen(hidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
+        LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
+                      "ifaceName too long";
+        return false;
+    }
+    strlcpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str(), IFNAMSIZ + 1);
+    legacy_request->ndp_cfg.security_cfg =
+            (hidl_request.securityConfig.securityType != NanDataPathSecurityType::OPEN)
+                    ? legacy_hal::NAN_DP_CONFIG_SECURITY
+                    : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
+    legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
+    if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
+        LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
+                      "ndp_app_info_len too large";
+        return false;
+    }
+    memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
+           legacy_request->app_info.ndp_app_info_len);
+    legacy_request->cipher_type = (unsigned int)hidl_request.securityConfig.cipherType;
+    if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PMK) {
+        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
+        legacy_request->key_info.body.pmk_info.pmk_len = hidl_request.securityConfig.pmk.size();
+        if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
+            LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
+                          "invalid pmk_len";
+            return false;
+        }
+        memcpy(legacy_request->key_info.body.pmk_info.pmk, hidl_request.securityConfig.pmk.data(),
+               legacy_request->key_info.body.pmk_info.pmk_len);
+    }
+    if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) {
+        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
+        legacy_request->key_info.body.passphrase_info.passphrase_len =
+                hidl_request.securityConfig.passphrase.size();
+        if (legacy_request->key_info.body.passphrase_info.passphrase_len <
+            NAN_SECURITY_MIN_PASSPHRASE_LEN) {
+            LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
+                          "passphrase_len too small";
+            return false;
+        }
+        if (legacy_request->key_info.body.passphrase_info.passphrase_len >
+            NAN_SECURITY_MAX_PASSPHRASE_LEN) {
+            LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
+                          "passphrase_len too large";
+            return false;
+        }
+        memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
+               hidl_request.securityConfig.passphrase.data(),
+               legacy_request->key_info.body.passphrase_info.passphrase_len);
+    }
+    legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
+    if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
+        LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
+                      "service_name_len too large";
+        return false;
+    }
+    memcpy(legacy_request->service_name, hidl_request.serviceNameOutOfBand.data(),
+           legacy_request->service_name_len);
+
+    return true;
+}
+
+bool convertHidlNanDataPathIndicationResponse_1_6ToLegacy(
+        const V1_6::NanRespondToDataPathIndicationRequest& hidl_request,
+        legacy_hal::NanDataPathIndicationResponse* legacy_request) {
+    if (!legacy_request) {
+        LOG(ERROR) << "convertHidlNanDataPathIndicationResponse_1_6ToLegacy: "
+                      "legacy_request is null";
+        return false;
+    }
+    *legacy_request = {};
+
+    legacy_request->rsp_code = hidl_request.acceptRequest ? legacy_hal::NAN_DP_REQUEST_ACCEPT
+                                                          : legacy_hal::NAN_DP_REQUEST_REJECT;
+    legacy_request->ndp_instance_id = hidl_request.ndpInstanceId;
+    if (strnlen(hidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
+        LOG(ERROR) << "convertHidlNanDataPathIndicationResponse_1_6ToLegacy: "
+                      "ifaceName too long";
+        return false;
+    }
+    strlcpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str(), IFNAMSIZ + 1);
+    legacy_request->ndp_cfg.security_cfg =
+            (hidl_request.securityConfig.securityType != NanDataPathSecurityType::OPEN)
+                    ? legacy_hal::NAN_DP_CONFIG_SECURITY
+                    : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
+    legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
+    if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
+        LOG(ERROR) << "convertHidlNanDataPathIndicationResponse_1_6ToLegacy: "
+                      "ndp_app_info_len too large";
+        return false;
+    }
+    memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
+           legacy_request->app_info.ndp_app_info_len);
+    legacy_request->cipher_type = (unsigned int)hidl_request.securityConfig.cipherType;
+    if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PMK) {
+        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
+        legacy_request->key_info.body.pmk_info.pmk_len = hidl_request.securityConfig.pmk.size();
+        if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
+            LOG(ERROR) << "convertHidlNanDataPathIndicationResponse_1_6ToLegacy: "
+                          "invalid pmk_len";
+            return false;
+        }
+        memcpy(legacy_request->key_info.body.pmk_info.pmk, hidl_request.securityConfig.pmk.data(),
+               legacy_request->key_info.body.pmk_info.pmk_len);
+    }
+    if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) {
+        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
+        legacy_request->key_info.body.passphrase_info.passphrase_len =
+                hidl_request.securityConfig.passphrase.size();
+        if (legacy_request->key_info.body.passphrase_info.passphrase_len <
+            NAN_SECURITY_MIN_PASSPHRASE_LEN) {
+            LOG(ERROR) << "convertHidlNanDataPathIndicationResponse_1_6ToLegacy: "
+                          "passphrase_len too small";
+            return false;
+        }
+        if (legacy_request->key_info.body.passphrase_info.passphrase_len >
+            NAN_SECURITY_MAX_PASSPHRASE_LEN) {
+            LOG(ERROR) << "convertHidlNanDataPathIndicationResponse_1_6ToLegacy: "
+                          "passphrase_len too large";
+            return false;
+        }
+        memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
+               hidl_request.securityConfig.passphrase.data(),
+               legacy_request->key_info.body.passphrase_info.passphrase_len);
+    }
+    legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
+    if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
+        LOG(ERROR) << "convertHidlNanDataPathIndicationResponse_1_6ToLegacy: "
+                      "service_name_len too large";
+        return false;
+    }
+    memcpy(legacy_request->service_name, hidl_request.serviceNameOutOfBand.data(),
+           legacy_request->service_name_len);
+    legacy_request->scid_len = hidl_request.securityConfig.scid.size();
+    if (legacy_request->scid_len > NAN_MAX_SCID_BUF_LEN) {
+        LOG(ERROR) << "convertHidlNanDataPathIndicationResponse_1_6ToLegacy: scid_len too large";
+        return false;
+    }
+    memcpy(legacy_request->scid, hidl_request.securityConfig.scid.data(), legacy_request->scid_len);
+
+    return true;
+}
+
+bool convertLegacyNanResponseHeaderToHidl(const legacy_hal::NanResponseMsg& legacy_response,
+                                          WifiNanStatus* wifiNanStatus) {
+    if (!wifiNanStatus) {
+        LOG(ERROR) << "convertLegacyNanResponseHeaderToHidl: wifiNanStatus is null";
+        return false;
+    }
+    *wifiNanStatus = {};
+
+    convertToWifiNanStatus(legacy_response.status, legacy_response.nan_error,
+                           sizeof(legacy_response.nan_error), wifiNanStatus);
+    return true;
+}
+
+bool convertLegacyNanCapabilitiesResponseToHidl(const legacy_hal::NanCapabilities& legacy_response,
+                                                V1_6::NanCapabilities* hidl_response) {
+    if (!hidl_response) {
+        LOG(ERROR) << "convertLegacyNanCapabilitiesResponseToHidl: "
+                      "hidl_response is null";
+        return false;
+    }
+    *hidl_response = {};
+
+    hidl_response->maxConcurrentClusters = legacy_response.max_concurrent_nan_clusters;
+    hidl_response->maxPublishes = legacy_response.max_publishes;
+    hidl_response->maxSubscribes = legacy_response.max_subscribes;
+    hidl_response->maxServiceNameLen = legacy_response.max_service_name_len;
+    hidl_response->maxMatchFilterLen = legacy_response.max_match_filter_len;
+    hidl_response->maxTotalMatchFilterLen = legacy_response.max_total_match_filter_len;
+    hidl_response->maxServiceSpecificInfoLen = legacy_response.max_service_specific_info_len;
+    hidl_response->maxExtendedServiceSpecificInfoLen =
+            legacy_response.max_sdea_service_specific_info_len;
+    hidl_response->maxNdiInterfaces = legacy_response.max_ndi_interfaces;
+    hidl_response->maxNdpSessions = legacy_response.max_ndp_sessions;
+    hidl_response->maxAppInfoLen = legacy_response.max_app_info_len;
+    hidl_response->maxQueuedTransmitFollowupMsgs =
+            legacy_response.max_queued_transmit_followup_msgs;
+    hidl_response->maxSubscribeInterfaceAddresses = legacy_response.max_subscribe_address;
+    hidl_response->supportedCipherSuites = legacy_response.cipher_suites_supported;
+    hidl_response->instantCommunicationModeSupportFlag = legacy_response.is_instant_mode_supported;
+
+    return true;
+}
+
+bool convertLegacyNanMatchIndToHidl(const legacy_hal::NanMatchInd& legacy_ind,
+                                    V1_6::NanMatchInd* hidl_ind) {
+    if (!hidl_ind) {
+        LOG(ERROR) << "convertLegacyNanMatchIndToHidl: hidl_ind is null";
+        return false;
+    }
+    *hidl_ind = {};
+
+    hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
+    hidl_ind->peerId = legacy_ind.requestor_instance_id;
+    hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
+    hidl_ind->serviceSpecificInfo = std::vector<uint8_t>(
+            legacy_ind.service_specific_info,
+            legacy_ind.service_specific_info + legacy_ind.service_specific_info_len);
+    hidl_ind->extendedServiceSpecificInfo = std::vector<uint8_t>(
+            legacy_ind.sdea_service_specific_info,
+            legacy_ind.sdea_service_specific_info + legacy_ind.sdea_service_specific_info_len);
+    hidl_ind->matchFilter =
+            std::vector<uint8_t>(legacy_ind.sdf_match_filter,
+                                 legacy_ind.sdf_match_filter + legacy_ind.sdf_match_filter_len);
+    hidl_ind->matchOccuredInBeaconFlag = legacy_ind.match_occured_flag == 1;
+    hidl_ind->outOfResourceFlag = legacy_ind.out_of_resource_flag == 1;
+    hidl_ind->rssiValue = legacy_ind.rssi_value;
+    hidl_ind->peerCipherType = (V1_6::NanCipherSuiteType)legacy_ind.peer_cipher_type;
+    hidl_ind->peerRequiresSecurityEnabledInNdp =
+            legacy_ind.peer_sdea_params.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
+    hidl_ind->peerRequiresRanging =
+            legacy_ind.peer_sdea_params.ranging_state == legacy_hal::NAN_RANGING_ENABLE;
+    hidl_ind->rangingMeasurementInMm = legacy_ind.range_info.range_measurement_mm;
+    hidl_ind->rangingIndicationType = legacy_ind.range_info.ranging_event_type;
+    hidl_ind->scid = std::vector<uint8_t>(legacy_ind.scid, legacy_ind.scid + legacy_ind.scid_len);
+    return true;
+}
+
+bool convertLegacyNanFollowupIndToHidl(const legacy_hal::NanFollowupInd& legacy_ind,
+                                       NanFollowupReceivedInd* hidl_ind) {
+    if (!hidl_ind) {
+        LOG(ERROR) << "convertLegacyNanFollowupIndToHidl: hidl_ind is null";
+        return false;
+    }
+    *hidl_ind = {};
+
+    hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
+    hidl_ind->peerId = legacy_ind.requestor_instance_id;
+    hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
+    hidl_ind->receivedInFaw = legacy_ind.dw_or_faw == 1;
+    hidl_ind->serviceSpecificInfo = std::vector<uint8_t>(
+            legacy_ind.service_specific_info,
+            legacy_ind.service_specific_info + legacy_ind.service_specific_info_len);
+    hidl_ind->extendedServiceSpecificInfo = std::vector<uint8_t>(
+            legacy_ind.sdea_service_specific_info,
+            legacy_ind.sdea_service_specific_info + legacy_ind.sdea_service_specific_info_len);
+
+    return true;
+}
+
+bool convertLegacyNanDataPathRequestIndToHidl(const legacy_hal::NanDataPathRequestInd& legacy_ind,
+                                              NanDataPathRequestInd* hidl_ind) {
+    if (!hidl_ind) {
+        LOG(ERROR) << "convertLegacyNanDataPathRequestIndToHidl: hidl_ind is null";
+        return false;
+    }
+    *hidl_ind = {};
+
+    hidl_ind->discoverySessionId = legacy_ind.service_instance_id;
+    hidl_ind->peerDiscMacAddr = hidl_array<uint8_t, 6>(legacy_ind.peer_disc_mac_addr);
+    hidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
+    hidl_ind->securityRequired =
+            legacy_ind.ndp_cfg.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
+    hidl_ind->appInfo = std::vector<uint8_t>(
+            legacy_ind.app_info.ndp_app_info,
+            legacy_ind.app_info.ndp_app_info + legacy_ind.app_info.ndp_app_info_len);
+
+    return true;
+}
+
+bool convertLegacyNdpChannelInfoToHidl(const legacy_hal::NanChannelInfo& legacy_struct,
+                                       V1_6::NanDataPathChannelInfo* hidl_struct) {
+    if (!hidl_struct) {
+        LOG(ERROR) << "convertLegacyNdpChannelInfoToHidl: hidl_struct is null";
+        return false;
+    }
+    *hidl_struct = {};
+
+    hidl_struct->channelFreq = legacy_struct.channel;
+    hidl_struct->channelBandwidth = convertLegacyWifiChannelWidthToHidl(
+            (legacy_hal::wifi_channel_width)legacy_struct.bandwidth);
+    hidl_struct->numSpatialStreams = legacy_struct.nss;
+
+    return true;
+}
+
+bool convertLegacyNanDataPathConfirmIndToHidl(const legacy_hal::NanDataPathConfirmInd& legacy_ind,
+                                              V1_6::NanDataPathConfirmInd* hidl_ind) {
+    if (!hidl_ind) {
+        LOG(ERROR) << "convertLegacyNanDataPathConfirmIndToHidl: hidl_ind is null";
+        return false;
+    }
+    *hidl_ind = {};
+
+    hidl_ind->V1_0.ndpInstanceId = legacy_ind.ndp_instance_id;
+    hidl_ind->V1_0.dataPathSetupSuccess = legacy_ind.rsp_code == legacy_hal::NAN_DP_REQUEST_ACCEPT;
+    hidl_ind->V1_0.peerNdiMacAddr = hidl_array<uint8_t, 6>(legacy_ind.peer_ndi_mac_addr);
+    hidl_ind->V1_0.appInfo = std::vector<uint8_t>(
+            legacy_ind.app_info.ndp_app_info,
+            legacy_ind.app_info.ndp_app_info + legacy_ind.app_info.ndp_app_info_len);
+    hidl_ind->V1_0.status.status = convertLegacyNanStatusTypeToHidl(legacy_ind.reason_code);
+    hidl_ind->V1_0.status.description = "";  // TODO: b/34059183
+
+    std::vector<V1_6::NanDataPathChannelInfo> channelInfo;
+    for (unsigned int i = 0; i < legacy_ind.num_channels; ++i) {
+        V1_6::NanDataPathChannelInfo hidl_struct;
+        if (!convertLegacyNdpChannelInfoToHidl(legacy_ind.channel_info[i], &hidl_struct)) {
+            return false;
+        }
+        channelInfo.push_back(hidl_struct);
+    }
+    hidl_ind->channelInfo = channelInfo;
+
+    return true;
+}
+
+bool convertLegacyNanDataPathScheduleUpdateIndToHidl(
+        const legacy_hal::NanDataPathScheduleUpdateInd& legacy_ind,
+        V1_6::NanDataPathScheduleUpdateInd* hidl_ind) {
+    if (!hidl_ind) {
+        LOG(ERROR) << "convertLegacyNanDataPathScheduleUpdateIndToHidl: "
+                      "hidl_ind is null";
+        return false;
+    }
+    *hidl_ind = {};
+
+    hidl_ind->peerDiscoveryAddress = hidl_array<uint8_t, 6>(legacy_ind.peer_mac_addr);
+    std::vector<V1_6::NanDataPathChannelInfo> channelInfo;
+    for (unsigned int i = 0; i < legacy_ind.num_channels; ++i) {
+        V1_6::NanDataPathChannelInfo hidl_struct;
+        if (!convertLegacyNdpChannelInfoToHidl(legacy_ind.channel_info[i], &hidl_struct)) {
+            return false;
+        }
+        channelInfo.push_back(hidl_struct);
+    }
+    hidl_ind->channelInfo = channelInfo;
+    std::vector<uint32_t> ndpInstanceIds;
+    for (unsigned int i = 0; i < legacy_ind.num_ndp_instances; ++i) {
+        ndpInstanceIds.push_back(legacy_ind.ndp_instance_id[i]);
+    }
+    hidl_ind->ndpInstanceIds = ndpInstanceIds;
+
+    return true;
+}
+
+legacy_hal::wifi_rtt_type convertHidlRttTypeToLegacy(RttType type) {
+    switch (type) {
+        case RttType::ONE_SIDED:
+            return legacy_hal::RTT_TYPE_1_SIDED;
+        case RttType::TWO_SIDED:
+            return legacy_hal::RTT_TYPE_2_SIDED;
+    };
+    CHECK(false);
+}
+
+RttType convertLegacyRttTypeToHidl(legacy_hal::wifi_rtt_type type) {
+    switch (type) {
+        case legacy_hal::RTT_TYPE_1_SIDED:
+            return RttType::ONE_SIDED;
+        case legacy_hal::RTT_TYPE_2_SIDED:
+            return RttType::TWO_SIDED;
+    };
+    CHECK(false) << "Unknown legacy type: " << type;
+}
+
+legacy_hal::rtt_peer_type convertHidlRttPeerTypeToLegacy(RttPeerType type) {
+    switch (type) {
+        case RttPeerType::AP:
+            return legacy_hal::RTT_PEER_AP;
+        case RttPeerType::STA:
+            return legacy_hal::RTT_PEER_STA;
+        case RttPeerType::P2P_GO:
+            return legacy_hal::RTT_PEER_P2P_GO;
+        case RttPeerType::P2P_CLIENT:
+            return legacy_hal::RTT_PEER_P2P_CLIENT;
+        case RttPeerType::NAN:
+            return legacy_hal::RTT_PEER_NAN;
+    };
+    CHECK(false);
+}
+
+legacy_hal::wifi_channel_width convertHidlWifiChannelWidthToLegacy(WifiChannelWidthInMhz type) {
+    switch (type) {
+        case WifiChannelWidthInMhz::WIDTH_20:
+            return legacy_hal::WIFI_CHAN_WIDTH_20;
+        case WifiChannelWidthInMhz::WIDTH_40:
+            return legacy_hal::WIFI_CHAN_WIDTH_40;
+        case WifiChannelWidthInMhz::WIDTH_80:
+            return legacy_hal::WIFI_CHAN_WIDTH_80;
+        case WifiChannelWidthInMhz::WIDTH_160:
+            return legacy_hal::WIFI_CHAN_WIDTH_160;
+        case WifiChannelWidthInMhz::WIDTH_80P80:
+            return legacy_hal::WIFI_CHAN_WIDTH_80P80;
+        case WifiChannelWidthInMhz::WIDTH_5:
+            return legacy_hal::WIFI_CHAN_WIDTH_5;
+        case WifiChannelWidthInMhz::WIDTH_10:
+            return legacy_hal::WIFI_CHAN_WIDTH_10;
+        case V1_6::WifiChannelWidthInMhz::WIDTH_320:
+            return legacy_hal::WIFI_CHAN_WIDTH_320;
+        case WifiChannelWidthInMhz::WIDTH_INVALID:
+            return legacy_hal::WIFI_CHAN_WIDTH_INVALID;
+    };
+    CHECK(false);
+}
+
+V1_6::WifiChannelWidthInMhz convertLegacyWifiChannelWidthToHidl(
+        legacy_hal::wifi_channel_width type) {
+    switch (type) {
+        case legacy_hal::WIFI_CHAN_WIDTH_20:
+            return WifiChannelWidthInMhz::WIDTH_20;
+        case legacy_hal::WIFI_CHAN_WIDTH_40:
+            return WifiChannelWidthInMhz::WIDTH_40;
+        case legacy_hal::WIFI_CHAN_WIDTH_80:
+            return WifiChannelWidthInMhz::WIDTH_80;
+        case legacy_hal::WIFI_CHAN_WIDTH_160:
+            return WifiChannelWidthInMhz::WIDTH_160;
+        case legacy_hal::WIFI_CHAN_WIDTH_80P80:
+            return WifiChannelWidthInMhz::WIDTH_80P80;
+        case legacy_hal::WIFI_CHAN_WIDTH_5:
+            return WifiChannelWidthInMhz::WIDTH_5;
+        case legacy_hal::WIFI_CHAN_WIDTH_10:
+            return WifiChannelWidthInMhz::WIDTH_10;
+        case legacy_hal::WIFI_CHAN_WIDTH_320:
+            return V1_6::WifiChannelWidthInMhz::WIDTH_320;
+        default:
+            return WifiChannelWidthInMhz::WIDTH_INVALID;
+    };
+}
+
+legacy_hal::wifi_rtt_preamble convertHidlRttPreambleToLegacy(V1_6::RttPreamble type) {
+    switch (type) {
+        case V1_6::RttPreamble::LEGACY:
+            return legacy_hal::WIFI_RTT_PREAMBLE_LEGACY;
+        case V1_6::RttPreamble::HT:
+            return legacy_hal::WIFI_RTT_PREAMBLE_HT;
+        case V1_6::RttPreamble::VHT:
+            return legacy_hal::WIFI_RTT_PREAMBLE_VHT;
+        case V1_6::RttPreamble::HE:
+            return legacy_hal::WIFI_RTT_PREAMBLE_HE;
+        case V1_6::RttPreamble::EHT:
+            return legacy_hal::WIFI_RTT_PREAMBLE_EHT;
+    };
+    CHECK(false);
+}
+
+V1_6::RttPreamble convertLegacyRttPreambleToHidl(legacy_hal::wifi_rtt_preamble type) {
+    switch (type) {
+        case legacy_hal::WIFI_RTT_PREAMBLE_LEGACY:
+            return V1_6::RttPreamble::LEGACY;
+        case legacy_hal::WIFI_RTT_PREAMBLE_HT:
+            return V1_6::RttPreamble::HT;
+        case legacy_hal::WIFI_RTT_PREAMBLE_VHT:
+            return V1_6::RttPreamble::VHT;
+        case legacy_hal::WIFI_RTT_PREAMBLE_HE:
+            return V1_6::RttPreamble::HE;
+        case legacy_hal::WIFI_RTT_PREAMBLE_EHT:
+            return V1_6::RttPreamble::EHT;
+    };
+    CHECK(false) << "Unknown legacy type: " << type;
+}
+
+legacy_hal::wifi_rtt_bw convertHidlRttBwToLegacy(RttBw type) {
+    switch (type) {
+        case RttBw::BW_5MHZ:
+            return legacy_hal::WIFI_RTT_BW_5;
+        case RttBw::BW_10MHZ:
+            return legacy_hal::WIFI_RTT_BW_10;
+        case RttBw::BW_20MHZ:
+            return legacy_hal::WIFI_RTT_BW_20;
+        case RttBw::BW_40MHZ:
+            return legacy_hal::WIFI_RTT_BW_40;
+        case RttBw::BW_80MHZ:
+            return legacy_hal::WIFI_RTT_BW_80;
+        case RttBw::BW_160MHZ:
+            return legacy_hal::WIFI_RTT_BW_160;
+        case RttBw::BW_320MHZ:
+            return legacy_hal::WIFI_RTT_BW_320;
+    };
+    CHECK(false);
+}
+
+RttBw convertLegacyRttBwToHidl(legacy_hal::wifi_rtt_bw type) {
+    switch (type) {
+        case legacy_hal::WIFI_RTT_BW_5:
+            return RttBw::BW_5MHZ;
+        case legacy_hal::WIFI_RTT_BW_10:
+            return RttBw::BW_10MHZ;
+        case legacy_hal::WIFI_RTT_BW_20:
+            return RttBw::BW_20MHZ;
+        case legacy_hal::WIFI_RTT_BW_40:
+            return RttBw::BW_40MHZ;
+        case legacy_hal::WIFI_RTT_BW_80:
+            return RttBw::BW_80MHZ;
+        case legacy_hal::WIFI_RTT_BW_160:
+            return RttBw::BW_160MHZ;
+        case legacy_hal::WIFI_RTT_BW_320:
+            return RttBw::BW_320MHZ;
+    };
+    CHECK(false) << "Unknown legacy type: " << type;
+}
+
+legacy_hal::wifi_motion_pattern convertHidlRttMotionPatternToLegacy(RttMotionPattern type) {
+    switch (type) {
+        case RttMotionPattern::NOT_EXPECTED:
+            return legacy_hal::WIFI_MOTION_NOT_EXPECTED;
+        case RttMotionPattern::EXPECTED:
+            return legacy_hal::WIFI_MOTION_EXPECTED;
+        case RttMotionPattern::UNKNOWN:
+            return legacy_hal::WIFI_MOTION_UNKNOWN;
+    };
+    CHECK(false);
+}
+
+V1_6::WifiRatePreamble convertLegacyWifiRatePreambleToHidl(uint8_t preamble) {
+    switch (preamble) {
+        case 0:
+            return V1_6::WifiRatePreamble::OFDM;
+        case 1:
+            return V1_6::WifiRatePreamble::CCK;
+        case 2:
+            return V1_6::WifiRatePreamble::HT;
+        case 3:
+            return V1_6::WifiRatePreamble::VHT;
+        case 4:
+            return V1_6::WifiRatePreamble::HE;
+        case 5:
+            return V1_6::WifiRatePreamble::EHT;
+        default:
+            return V1_6::WifiRatePreamble::RESERVED;
+    };
+    CHECK(false) << "Unknown legacy preamble: " << preamble;
+}
+
+WifiRateNss convertLegacyWifiRateNssToHidl(uint8_t nss) {
+    switch (nss) {
+        case 0:
+            return WifiRateNss::NSS_1x1;
+        case 1:
+            return WifiRateNss::NSS_2x2;
+        case 2:
+            return WifiRateNss::NSS_3x3;
+        case 3:
+            return WifiRateNss::NSS_4x4;
+    };
+    CHECK(false) << "Unknown legacy nss: " << nss;
+    return {};
+}
+
+RttStatus convertLegacyRttStatusToHidl(legacy_hal::wifi_rtt_status status) {
+    switch (status) {
+        case legacy_hal::RTT_STATUS_SUCCESS:
+            return RttStatus::SUCCESS;
+        case legacy_hal::RTT_STATUS_FAILURE:
+            return RttStatus::FAILURE;
+        case legacy_hal::RTT_STATUS_FAIL_NO_RSP:
+            return RttStatus::FAIL_NO_RSP;
+        case legacy_hal::RTT_STATUS_FAIL_REJECTED:
+            return RttStatus::FAIL_REJECTED;
+        case legacy_hal::RTT_STATUS_FAIL_NOT_SCHEDULED_YET:
+            return RttStatus::FAIL_NOT_SCHEDULED_YET;
+        case legacy_hal::RTT_STATUS_FAIL_TM_TIMEOUT:
+            return RttStatus::FAIL_TM_TIMEOUT;
+        case legacy_hal::RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL:
+            return RttStatus::FAIL_AP_ON_DIFF_CHANNEL;
+        case legacy_hal::RTT_STATUS_FAIL_NO_CAPABILITY:
+            return RttStatus::FAIL_NO_CAPABILITY;
+        case legacy_hal::RTT_STATUS_ABORTED:
+            return RttStatus::ABORTED;
+        case legacy_hal::RTT_STATUS_FAIL_INVALID_TS:
+            return RttStatus::FAIL_INVALID_TS;
+        case legacy_hal::RTT_STATUS_FAIL_PROTOCOL:
+            return RttStatus::FAIL_PROTOCOL;
+        case legacy_hal::RTT_STATUS_FAIL_SCHEDULE:
+            return RttStatus::FAIL_SCHEDULE;
+        case legacy_hal::RTT_STATUS_FAIL_BUSY_TRY_LATER:
+            return RttStatus::FAIL_BUSY_TRY_LATER;
+        case legacy_hal::RTT_STATUS_INVALID_REQ:
+            return RttStatus::INVALID_REQ;
+        case legacy_hal::RTT_STATUS_NO_WIFI:
+            return RttStatus::NO_WIFI;
+        case legacy_hal::RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE:
+            return RttStatus::FAIL_FTM_PARAM_OVERRIDE;
+        case legacy_hal::RTT_STATUS_NAN_RANGING_PROTOCOL_FAILURE:
+            return RttStatus::FAILURE;  // TODO: add HIDL enumeration
+        case legacy_hal::RTT_STATUS_NAN_RANGING_CONCURRENCY_NOT_SUPPORTED:
+            return RttStatus::FAILURE;  // TODO: add HIDL enumeration
+    };
+    CHECK(false) << "Unknown legacy status: " << status;
+}
+
+bool convertHidlWifiChannelInfoToLegacy(const WifiChannelInfo& hidl_info,
+                                        legacy_hal::wifi_channel_info* legacy_info) {
+    if (!legacy_info) {
+        return false;
+    }
+    *legacy_info = {};
+    legacy_info->width = convertHidlWifiChannelWidthToLegacy(hidl_info.width);
+    legacy_info->center_freq = hidl_info.centerFreq;
+    legacy_info->center_freq0 = hidl_info.centerFreq0;
+    legacy_info->center_freq1 = hidl_info.centerFreq1;
+    return true;
+}
+
+bool convertLegacyWifiChannelInfoToHidl(const legacy_hal::wifi_channel_info& legacy_info,
+                                        WifiChannelInfo* hidl_info) {
+    if (!hidl_info) {
+        return false;
+    }
+    *hidl_info = {};
+    hidl_info->width = convertLegacyWifiChannelWidthToHidl(legacy_info.width);
+    hidl_info->centerFreq = legacy_info.center_freq;
+    hidl_info->centerFreq0 = legacy_info.center_freq0;
+    hidl_info->centerFreq1 = legacy_info.center_freq1;
+    return true;
+}
+
+bool convertHidlRttConfigToLegacy(const V1_6::RttConfig& hidl_config,
+                                  legacy_hal::wifi_rtt_config* legacy_config) {
+    if (!legacy_config) {
+        return false;
+    }
+    *legacy_config = {};
+    CHECK(hidl_config.addr.size() == sizeof(legacy_config->addr));
+    memcpy(legacy_config->addr, hidl_config.addr.data(), hidl_config.addr.size());
+    legacy_config->type = convertHidlRttTypeToLegacy(hidl_config.type);
+    legacy_config->peer = convertHidlRttPeerTypeToLegacy(hidl_config.peer);
+    if (!convertHidlWifiChannelInfoToLegacy(hidl_config.channel, &legacy_config->channel)) {
+        return false;
+    }
+    legacy_config->burst_period = hidl_config.burstPeriod;
+    legacy_config->num_burst = hidl_config.numBurst;
+    legacy_config->num_frames_per_burst = hidl_config.numFramesPerBurst;
+    legacy_config->num_retries_per_rtt_frame = hidl_config.numRetriesPerRttFrame;
+    legacy_config->num_retries_per_ftmr = hidl_config.numRetriesPerFtmr;
+    legacy_config->LCI_request = hidl_config.mustRequestLci;
+    legacy_config->LCR_request = hidl_config.mustRequestLcr;
+    legacy_config->burst_duration = hidl_config.burstDuration;
+    legacy_config->preamble = convertHidlRttPreambleToLegacy(hidl_config.preamble);
+    legacy_config->bw = convertHidlRttBwToLegacy(hidl_config.bw);
+    return true;
+}
+
+bool convertHidlVectorOfRttConfigToLegacy(
+        const std::vector<V1_6::RttConfig>& hidl_configs,
+        std::vector<legacy_hal::wifi_rtt_config>* legacy_configs) {
+    if (!legacy_configs) {
+        return false;
+    }
+    *legacy_configs = {};
+    for (const auto& hidl_config : hidl_configs) {
+        legacy_hal::wifi_rtt_config legacy_config;
+        if (!convertHidlRttConfigToLegacy(hidl_config, &legacy_config)) {
+            return false;
+        }
+        legacy_configs->push_back(legacy_config);
+    }
+    return true;
+}
+
+bool convertHidlRttLciInformationToLegacy(const RttLciInformation& hidl_info,
+                                          legacy_hal::wifi_lci_information* legacy_info) {
+    if (!legacy_info) {
+        return false;
+    }
+    *legacy_info = {};
+    legacy_info->latitude = hidl_info.latitude;
+    legacy_info->longitude = hidl_info.longitude;
+    legacy_info->altitude = hidl_info.altitude;
+    legacy_info->latitude_unc = hidl_info.latitudeUnc;
+    legacy_info->longitude_unc = hidl_info.longitudeUnc;
+    legacy_info->altitude_unc = hidl_info.altitudeUnc;
+    legacy_info->motion_pattern = convertHidlRttMotionPatternToLegacy(hidl_info.motionPattern);
+    legacy_info->floor = hidl_info.floor;
+    legacy_info->height_above_floor = hidl_info.heightAboveFloor;
+    legacy_info->height_unc = hidl_info.heightUnc;
+    return true;
+}
+
+bool convertHidlRttLcrInformationToLegacy(const RttLcrInformation& hidl_info,
+                                          legacy_hal::wifi_lcr_information* legacy_info) {
+    if (!legacy_info) {
+        return false;
+    }
+    *legacy_info = {};
+    CHECK(hidl_info.countryCode.size() == sizeof(legacy_info->country_code));
+    memcpy(legacy_info->country_code, hidl_info.countryCode.data(), hidl_info.countryCode.size());
+    if (hidl_info.civicInfo.size() > sizeof(legacy_info->civic_info)) {
+        return false;
+    }
+    legacy_info->length = hidl_info.civicInfo.size();
+    memcpy(legacy_info->civic_info, hidl_info.civicInfo.c_str(), hidl_info.civicInfo.size());
+    return true;
+}
+
+bool convertHidlRttResponderToLegacy(const V1_6::RttResponder& hidl_responder,
+                                     legacy_hal::wifi_rtt_responder* legacy_responder) {
+    if (!legacy_responder) {
+        return false;
+    }
+    *legacy_responder = {};
+    if (!convertHidlWifiChannelInfoToLegacy(hidl_responder.channel, &legacy_responder->channel)) {
+        return false;
+    }
+    legacy_responder->preamble = convertHidlRttPreambleToLegacy(hidl_responder.preamble);
+    return true;
+}
+
+bool convertLegacyRttResponderToHidl(const legacy_hal::wifi_rtt_responder& legacy_responder,
+                                     V1_6::RttResponder* hidl_responder) {
+    if (!hidl_responder) {
+        return false;
+    }
+    *hidl_responder = {};
+    if (!convertLegacyWifiChannelInfoToHidl(legacy_responder.channel, &hidl_responder->channel)) {
+        return false;
+    }
+    hidl_responder->preamble = convertLegacyRttPreambleToHidl(legacy_responder.preamble);
+    return true;
+}
+
+bool convertLegacyRttCapabilitiesToHidl(
+        const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
+        V1_6::RttCapabilities* hidl_capabilities) {
+    if (!hidl_capabilities) {
+        return false;
+    }
+    *hidl_capabilities = {};
+    hidl_capabilities->rttOneSidedSupported = legacy_capabilities.rtt_one_sided_supported;
+    hidl_capabilities->rttFtmSupported = legacy_capabilities.rtt_ftm_supported;
+    hidl_capabilities->lciSupported = legacy_capabilities.lci_support;
+    hidl_capabilities->lcrSupported = legacy_capabilities.lcr_support;
+    hidl_capabilities->responderSupported = legacy_capabilities.responder_supported;
+    hidl_capabilities->preambleSupport = 0;
+    for (const auto flag : {legacy_hal::WIFI_RTT_PREAMBLE_LEGACY, legacy_hal::WIFI_RTT_PREAMBLE_HT,
+                            legacy_hal::WIFI_RTT_PREAMBLE_VHT, legacy_hal::WIFI_RTT_PREAMBLE_HE,
+                            legacy_hal::WIFI_RTT_PREAMBLE_EHT}) {
+        if (legacy_capabilities.preamble_support & flag) {
+            hidl_capabilities->preambleSupport |=
+                    static_cast<std::underlying_type<V1_6::RttPreamble>::type>(
+                            convertLegacyRttPreambleToHidl(flag));
+        }
+    }
+    hidl_capabilities->bwSupport = 0;
+    for (const auto flag :
+         {legacy_hal::WIFI_RTT_BW_5, legacy_hal::WIFI_RTT_BW_10, legacy_hal::WIFI_RTT_BW_20,
+          legacy_hal::WIFI_RTT_BW_40, legacy_hal::WIFI_RTT_BW_80, legacy_hal::WIFI_RTT_BW_160,
+          legacy_hal::WIFI_RTT_BW_320}) {
+        if (legacy_capabilities.bw_support & flag) {
+            hidl_capabilities->bwSupport |=
+                    static_cast<std::underlying_type<RttBw>::type>(convertLegacyRttBwToHidl(flag));
+        }
+    }
+    hidl_capabilities->mcVersion = legacy_capabilities.mc_version;
+    return true;
+}
+
+bool convertLegacyWifiRateInfoToHidl(const legacy_hal::wifi_rate& legacy_rate,
+                                     V1_6::WifiRateInfo* hidl_rate) {
+    if (!hidl_rate) {
+        return false;
+    }
+    *hidl_rate = {};
+    hidl_rate->preamble = convertLegacyWifiRatePreambleToHidl(legacy_rate.preamble);
+    hidl_rate->nss = convertLegacyWifiRateNssToHidl(legacy_rate.nss);
+    hidl_rate->bw = convertLegacyWifiChannelWidthToHidl(
+            static_cast<legacy_hal::wifi_channel_width>(legacy_rate.bw));
+    hidl_rate->rateMcsIdx = legacy_rate.rateMcsIdx;
+    hidl_rate->bitRateInKbps = legacy_rate.bitrate;
+    return true;
+}
+
+bool convertLegacyRttResultToHidl(const legacy_hal::wifi_rtt_result& legacy_result,
+                                  V1_6::RttResult* hidl_result) {
+    if (!hidl_result) {
+        return false;
+    }
+    *hidl_result = {};
+    CHECK(sizeof(legacy_result.addr) == hidl_result->addr.size());
+    memcpy(hidl_result->addr.data(), legacy_result.addr, sizeof(legacy_result.addr));
+    hidl_result->burstNum = legacy_result.burst_num;
+    hidl_result->measurementNumber = legacy_result.measurement_number;
+    hidl_result->successNumber = legacy_result.success_number;
+    hidl_result->numberPerBurstPeer = legacy_result.number_per_burst_peer;
+    hidl_result->status = convertLegacyRttStatusToHidl(legacy_result.status);
+    hidl_result->retryAfterDuration = legacy_result.retry_after_duration;
+    hidl_result->type = convertLegacyRttTypeToHidl(legacy_result.type);
+    hidl_result->rssi = legacy_result.rssi;
+    hidl_result->rssiSpread = legacy_result.rssi_spread;
+    if (!convertLegacyWifiRateInfoToHidl(legacy_result.tx_rate, &hidl_result->txRate)) {
+        return false;
+    }
+    if (!convertLegacyWifiRateInfoToHidl(legacy_result.rx_rate, &hidl_result->rxRate)) {
+        return false;
+    }
+    hidl_result->rtt = legacy_result.rtt;
+    hidl_result->rttSd = legacy_result.rtt_sd;
+    hidl_result->rttSpread = legacy_result.rtt_spread;
+    hidl_result->distanceInMm = legacy_result.distance_mm;
+    hidl_result->distanceSdInMm = legacy_result.distance_sd_mm;
+    hidl_result->distanceSpreadInMm = legacy_result.distance_spread_mm;
+    hidl_result->timeStampInUs = legacy_result.ts;
+    hidl_result->burstDurationInMs = legacy_result.burst_duration;
+    hidl_result->negotiatedBurstNum = legacy_result.negotiated_burst_num;
+    if (legacy_result.LCI && !convertLegacyIeToHidl(*legacy_result.LCI, &hidl_result->lci)) {
+        return false;
+    }
+    if (legacy_result.LCR && !convertLegacyIeToHidl(*legacy_result.LCR, &hidl_result->lcr)) {
+        return false;
+    }
+    return true;
+}
+
+bool convertLegacyVectorOfRttResultToHidl(
+        const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
+        std::vector<V1_6::RttResult>* hidl_results) {
+    if (!hidl_results) {
+        return false;
+    }
+    *hidl_results = {};
+    for (const auto legacy_result : legacy_results) {
+        V1_6::RttResult hidl_result;
+        if (!convertLegacyRttResultToHidl(*legacy_result, &hidl_result)) {
+            return false;
+        }
+        hidl_results->push_back(hidl_result);
+    }
+    return true;
+}
+
+legacy_hal::wifi_interface_type convertHidlIfaceTypeToLegacy(IfaceType hidl_interface_type) {
+    switch (hidl_interface_type) {
+        case IfaceType::STA:
+            return legacy_hal::WIFI_INTERFACE_TYPE_STA;
+        case IfaceType::AP:
+            return legacy_hal::WIFI_INTERFACE_TYPE_AP;
+        case IfaceType::P2P:
+            return legacy_hal::WIFI_INTERFACE_TYPE_P2P;
+        case IfaceType::NAN:
+            return legacy_hal::WIFI_INTERFACE_TYPE_NAN;
+    }
+    CHECK(false);
+}
+
+legacy_hal::wifi_multi_sta_use_case convertHidlMultiStaUseCaseToLegacy(
+        V1_5::IWifiChip::MultiStaUseCase use_case) {
+    switch (use_case) {
+        case V1_5::IWifiChip::MultiStaUseCase::DUAL_STA_TRANSIENT_PREFER_PRIMARY:
+            return legacy_hal::WIFI_DUAL_STA_TRANSIENT_PREFER_PRIMARY;
+        case V1_5::IWifiChip::MultiStaUseCase::DUAL_STA_NON_TRANSIENT_UNBIASED:
+            return legacy_hal::WIFI_DUAL_STA_NON_TRANSIENT_UNBIASED;
+    }
+    CHECK(false);
+}
+
+bool convertHidlCoexUnsafeChannelToLegacy(
+        const V1_5::IWifiChip::CoexUnsafeChannel& hidl_unsafe_channel,
+        legacy_hal::wifi_coex_unsafe_channel* legacy_unsafe_channel) {
+    if (!legacy_unsafe_channel) {
+        return false;
+    }
+    *legacy_unsafe_channel = {};
+    switch (hidl_unsafe_channel.band) {
+        case V1_5::WifiBand::BAND_24GHZ:
+            legacy_unsafe_channel->band = legacy_hal::WLAN_MAC_2_4_BAND;
+            break;
+        case V1_5::WifiBand::BAND_5GHZ:
+            legacy_unsafe_channel->band = legacy_hal::WLAN_MAC_5_0_BAND;
+            break;
+        default:
+            return false;
+    };
+    legacy_unsafe_channel->channel = hidl_unsafe_channel.channel;
+    legacy_unsafe_channel->power_cap_dbm = hidl_unsafe_channel.powerCapDbm;
+    return true;
+}
+
+bool convertHidlVectorOfCoexUnsafeChannelToLegacy(
+        const std::vector<V1_5::IWifiChip::CoexUnsafeChannel>& hidl_unsafe_channels,
+        std::vector<legacy_hal::wifi_coex_unsafe_channel>* legacy_unsafe_channels) {
+    if (!legacy_unsafe_channels) {
+        return false;
+    }
+    *legacy_unsafe_channels = {};
+    for (const auto& hidl_unsafe_channel : hidl_unsafe_channels) {
+        legacy_hal::wifi_coex_unsafe_channel legacy_unsafe_channel;
+        if (!hidl_struct_util::convertHidlCoexUnsafeChannelToLegacy(hidl_unsafe_channel,
+                                                                    &legacy_unsafe_channel)) {
+            return false;
+        }
+        legacy_unsafe_channels->push_back(legacy_unsafe_channel);
+    }
+    return true;
+}
+
+V1_6::WifiAntennaMode convertLegacyAntennaConfigurationToHidl(uint32_t antenna_cfg) {
+    switch (antenna_cfg) {
+        case legacy_hal::WIFI_ANTENNA_1X1:
+            return V1_6::WifiAntennaMode::WIFI_ANTENNA_MODE_1X1;
+        case legacy_hal::WIFI_ANTENNA_2X2:
+            return V1_6::WifiAntennaMode::WIFI_ANTENNA_MODE_2X2;
+        case legacy_hal::WIFI_ANTENNA_3X3:
+            return V1_6::WifiAntennaMode::WIFI_ANTENNA_MODE_3X3;
+        case legacy_hal::WIFI_ANTENNA_4X4:
+            return V1_6::WifiAntennaMode::WIFI_ANTENNA_MODE_4X4;
+        default:
+            return V1_6::WifiAntennaMode::WIFI_ANTENNA_MODE_UNSPECIFIED;
+    }
+}
+
+bool convertLegacyWifiRadioConfigurationToHidl(
+        legacy_hal::wifi_radio_configuration* radio_configuration,
+        V1_6::WifiRadioConfiguration* hidl_radio_configuration) {
+    if (!hidl_radio_configuration) {
+        return false;
+    }
+    *hidl_radio_configuration = {};
+    hidl_radio_configuration->bandInfo =
+            hidl_struct_util::convertLegacyMacBandToHidlWifiBand(radio_configuration->band);
+    if (hidl_radio_configuration->bandInfo == V1_5::WifiBand::BAND_UNSPECIFIED) {
+        LOG(ERROR) << "Unspecified band";
+        return false;
+    }
+    hidl_radio_configuration->antennaMode =
+            hidl_struct_util::convertLegacyAntennaConfigurationToHidl(
+                    radio_configuration->antenna_cfg);
+    return true;
+}
+
+bool convertLegacyRadioCombinationsMatrixToHidl(
+        legacy_hal::wifi_radio_combination_matrix* legacy_matrix,
+        WifiRadioCombinationMatrix* hidl_matrix) {
+    if (!hidl_matrix || !legacy_matrix) {
+        return false;
+    }
+    *hidl_matrix = {};
+
+    int num_combinations = legacy_matrix->num_radio_combinations;
+    std::vector<V1_6::WifiRadioCombination> radio_combinations_vec;
+    if (!num_combinations) {
+        LOG(ERROR) << "zero radio combinations";
+        return false;
+    }
+    wifi_radio_combination* l_radio_combinations_ptr = legacy_matrix->radio_combinations;
+    for (int i = 0; i < num_combinations; i++) {
+        int num_configurations = l_radio_combinations_ptr->num_radio_configurations;
+        WifiRadioCombination radioCombination;
+        std::vector<V1_6::WifiRadioConfiguration> radio_configurations_vec;
+        if (!num_configurations) {
+            LOG(ERROR) << "zero radio configurations";
+            return false;
+        }
+        for (int j = 0; j < num_configurations; j++) {
+            WifiRadioConfiguration radioConfiguration;
+            wifi_radio_configuration* l_radio_configurations_ptr =
+                    &l_radio_combinations_ptr->radio_configurations[j];
+            if (!hidl_struct_util::convertLegacyWifiRadioConfigurationToHidl(
+                        l_radio_configurations_ptr, &radioConfiguration)) {
+                LOG(ERROR) << "Error converting wifi radio configuration";
+                return false;
+            }
+            radio_configurations_vec.push_back(radioConfiguration);
+        }
+        radioCombination.radioConfigurations = radio_configurations_vec;
+        radio_combinations_vec.push_back(radioCombination);
+        l_radio_combinations_ptr =
+                (wifi_radio_combination*)((u8*)l_radio_combinations_ptr +
+                                          sizeof(wifi_radio_combination) +
+                                          (sizeof(wifi_radio_configuration) * num_configurations));
+    }
+    hidl_matrix->radioCombinations = radio_combinations_vec;
+    return true;
+}
+
+}  // namespace hidl_struct_util
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
diff --git a/wifi/1.6/default/hidl_struct_util.h b/wifi/1.6/default/hidl_struct_util.h
new file mode 100644
index 0000000..2d4a5f1
--- /dev/null
+++ b/wifi/1.6/default/hidl_struct_util.h
@@ -0,0 +1,204 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HIDL_STRUCT_UTIL_H_
+#define HIDL_STRUCT_UTIL_H_
+
+#include <vector>
+
+#include <android/hardware/wifi/1.0/IWifiChip.h>
+#include <android/hardware/wifi/1.0/types.h>
+#include <android/hardware/wifi/1.2/types.h>
+#include <android/hardware/wifi/1.3/types.h>
+#include <android/hardware/wifi/1.4/IWifiChipEventCallback.h>
+#include <android/hardware/wifi/1.4/types.h>
+#include <android/hardware/wifi/1.6/IWifiChip.h>
+#include <android/hardware/wifi/1.6/types.h>
+
+#include "wifi_legacy_hal.h"
+
+/**
+ * This file contains a bunch of functions to convert structs from the legacy
+ * HAL to HIDL and vice versa.
+ * TODO(b/32093047): Add unit tests for these conversion methods in the VTS test
+ * suite.
+ */
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+namespace hidl_struct_util {
+using namespace android::hardware::wifi::V1_0;
+
+// Chip conversion methods.
+bool convertLegacyFeaturesToHidlChipCapabilities(uint64_t legacy_feature_set,
+                                                 uint32_t legacy_logger_feature_set,
+                                                 uint32_t* hidl_caps);
+bool convertLegacyDebugRingBufferStatusToHidl(
+        const legacy_hal::wifi_ring_buffer_status& legacy_status,
+        WifiDebugRingBufferStatus* hidl_status);
+bool convertLegacyVectorOfDebugRingBufferStatusToHidl(
+        const std::vector<legacy_hal::wifi_ring_buffer_status>& legacy_status_vec,
+        std::vector<WifiDebugRingBufferStatus>* hidl_status_vec);
+bool convertLegacyWakeReasonStatsToHidl(const legacy_hal::WakeReasonStats& legacy_stats,
+                                        WifiDebugHostWakeReasonStats* hidl_stats);
+legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy(
+        V1_1::IWifiChip::TxPowerScenario hidl_scenario);
+legacy_hal::wifi_latency_mode convertHidlLatencyModeToLegacy(
+        V1_3::IWifiChip::LatencyMode hidl_latency_mode);
+legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy_1_2(
+        V1_2::IWifiChip::TxPowerScenario hidl_scenario);
+bool convertLegacyWifiMacInfosToHidl(
+        const std::vector<legacy_hal::WifiMacInfo>& legacy_mac_infos,
+        std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo>* hidl_radio_mode_infos);
+legacy_hal::wifi_interface_type convertHidlIfaceTypeToLegacy(IfaceType hidl_interface_type);
+legacy_hal::wifi_multi_sta_use_case convertHidlMultiStaUseCaseToLegacy(
+        V1_5::IWifiChip::MultiStaUseCase use_case);
+bool convertHidlCoexUnsafeChannelToLegacy(
+        const V1_5::IWifiChip::CoexUnsafeChannel& hidl_unsafe_channel,
+        legacy_hal::wifi_coex_unsafe_channel* legacy_unsafe_channel);
+bool convertHidlVectorOfCoexUnsafeChannelToLegacy(
+        const std::vector<V1_5::IWifiChip::CoexUnsafeChannel>& hidl_unsafe_channels,
+        std::vector<legacy_hal::wifi_coex_unsafe_channel>* legacy_unsafe_channels);
+bool convertLegacyRadioCombinationsMatrixToHidl(
+        legacy_hal::wifi_radio_combination_matrix* legacy_matrix,
+        V1_6::WifiRadioCombinationMatrix* hidl_matrix);
+V1_5::WifiBand convertLegacyMacBandToHidlWifiBand(uint32_t band);
+V1_6::WifiAntennaMode convertLegacyAntennaConfigurationToHidl(uint32_t antenna_cfg);
+
+// STA iface conversion methods.
+bool convertLegacyFeaturesToHidlStaCapabilities(uint64_t legacy_feature_set,
+                                                uint32_t legacy_logger_feature_set,
+                                                uint32_t* hidl_caps);
+bool convertLegacyApfCapabilitiesToHidl(const legacy_hal::PacketFilterCapabilities& legacy_caps,
+                                        StaApfPacketFilterCapabilities* hidl_caps);
+bool convertLegacyGscanCapabilitiesToHidl(const legacy_hal::wifi_gscan_capabilities& legacy_caps,
+                                          StaBackgroundScanCapabilities* hidl_caps);
+legacy_hal::wifi_band convertHidlWifiBandToLegacy(V1_0::WifiBand band);
+bool convertHidlGscanParamsToLegacy(const StaBackgroundScanParameters& hidl_scan_params,
+                                    legacy_hal::wifi_scan_cmd_params* legacy_scan_params);
+// |has_ie_data| indicates whether or not the wifi_scan_result includes 802.11
+// Information Elements (IEs)
+bool convertLegacyGscanResultToHidl(const legacy_hal::wifi_scan_result& legacy_scan_result,
+                                    bool has_ie_data, StaScanResult* hidl_scan_result);
+// |cached_results| is assumed to not include IEs.
+bool convertLegacyVectorOfCachedGscanResultsToHidl(
+        const std::vector<legacy_hal::wifi_cached_scan_results>& legacy_cached_scan_results,
+        std::vector<StaScanData>* hidl_scan_datas);
+bool convertLegacyLinkLayerStatsToHidl(const legacy_hal::LinkLayerStats& legacy_stats,
+                                       V1_6::StaLinkLayerStats* hidl_stats);
+bool convertLegacyRoamingCapabilitiesToHidl(
+        const legacy_hal::wifi_roaming_capabilities& legacy_caps,
+        StaRoamingCapabilities* hidl_caps);
+bool convertHidlRoamingConfigToLegacy(const StaRoamingConfig& hidl_config,
+                                      legacy_hal::wifi_roaming_config* legacy_config);
+legacy_hal::fw_roaming_state_t convertHidlRoamingStateToLegacy(StaRoamingState state);
+bool convertLegacyVectorOfDebugTxPacketFateToHidl(
+        const std::vector<legacy_hal::wifi_tx_report>& legacy_fates,
+        std::vector<WifiDebugTxPacketFateReport>* hidl_fates);
+bool convertLegacyVectorOfDebugRxPacketFateToHidl(
+        const std::vector<legacy_hal::wifi_rx_report>& legacy_fates,
+        std::vector<WifiDebugRxPacketFateReport>* hidl_fates);
+
+// NAN iface conversion methods.
+void convertToWifiNanStatus(legacy_hal::NanStatusType type, const char* str, size_t max_len,
+                            WifiNanStatus* wifiNanStatus);
+bool convertHidlNanEnableRequestToLegacy(const V1_4::NanEnableRequest& hidl_request,
+                                         legacy_hal::NanEnableRequest* legacy_request);
+bool convertHidlNanConfigRequestToLegacy(const V1_4::NanConfigRequest& hidl_request,
+                                         legacy_hal::NanConfigRequest* legacy_request);
+bool convertHidlNanEnableRequest_1_6ToLegacy(
+        const V1_4::NanEnableRequest& hidl_request1,
+        const V1_6::NanConfigRequestSupplemental& hidl_request2,
+        legacy_hal::NanEnableRequest* legacy_request);
+bool convertHidlNanConfigRequest_1_6ToLegacy(
+        const V1_4::NanConfigRequest& hidl_request1,
+        const V1_6::NanConfigRequestSupplemental& hidl_request2,
+        legacy_hal::NanConfigRequest* legacy_request);
+bool convertHidlNanPublishRequestToLegacy(const V1_6::NanPublishRequest& hidl_request,
+                                          legacy_hal::NanPublishRequest* legacy_request);
+bool convertHidlNanSubscribeRequestToLegacy(const V1_0::NanSubscribeRequest& hidl_request,
+                                            legacy_hal::NanSubscribeRequest* legacy_request);
+bool convertHidlNanTransmitFollowupRequestToLegacy(
+        const NanTransmitFollowupRequest& hidl_request,
+        legacy_hal::NanTransmitFollowupRequest* legacy_request);
+bool convertHidlNanDataPathInitiatorRequestToLegacy(
+        const V1_0::NanInitiateDataPathRequest& hidl_request,
+        legacy_hal::NanDataPathInitiatorRequest* legacy_request);
+bool convertHidlNanDataPathIndicationResponseToLegacy(
+        const V1_0::NanRespondToDataPathIndicationRequest& hidl_response,
+        legacy_hal::NanDataPathIndicationResponse* legacy_response);
+bool convertHidlNanDataPathInitiatorRequest_1_6ToLegacy(
+        const V1_6::NanInitiateDataPathRequest& hidl_request,
+        legacy_hal::NanDataPathInitiatorRequest* legacy_request);
+bool convertHidlNanDataPathIndicationResponse_1_6ToLegacy(
+        const V1_6::NanRespondToDataPathIndicationRequest& hidl_response,
+        legacy_hal::NanDataPathIndicationResponse* legacy_response);
+
+bool convertLegacyNanResponseHeaderToHidl(const legacy_hal::NanResponseMsg& legacy_response,
+                                          WifiNanStatus* wifiNanStatus);
+bool convertLegacyNanCapabilitiesResponseToHidl(const legacy_hal::NanCapabilities& legacy_response,
+                                                V1_6::NanCapabilities* hidl_response);
+bool convertLegacyNanMatchIndToHidl(const legacy_hal::NanMatchInd& legacy_ind,
+                                    V1_6::NanMatchInd* hidl_ind);
+bool convertLegacyNanFollowupIndToHidl(const legacy_hal::NanFollowupInd& legacy_ind,
+                                       NanFollowupReceivedInd* hidl_ind);
+bool convertLegacyNanDataPathRequestIndToHidl(const legacy_hal::NanDataPathRequestInd& legacy_ind,
+                                              NanDataPathRequestInd* hidl_ind);
+bool convertLegacyNanDataPathConfirmIndToHidl(const legacy_hal::NanDataPathConfirmInd& legacy_ind,
+                                              V1_6::NanDataPathConfirmInd* hidl_ind);
+bool convertLegacyNanDataPathScheduleUpdateIndToHidl(
+        const legacy_hal::NanDataPathScheduleUpdateInd& legacy_ind,
+        V1_6::NanDataPathScheduleUpdateInd* hidl_ind);
+
+// RTT controller conversion methods.
+bool convertHidlVectorOfRttConfigToLegacy(const std::vector<V1_6::RttConfig>& hidl_configs,
+                                          std::vector<legacy_hal::wifi_rtt_config>* legacy_configs);
+bool convertHidlRttLciInformationToLegacy(const RttLciInformation& hidl_info,
+                                          legacy_hal::wifi_lci_information* legacy_info);
+bool convertHidlRttLcrInformationToLegacy(const RttLcrInformation& hidl_info,
+                                          legacy_hal::wifi_lcr_information* legacy_info);
+bool convertHidlRttResponderToLegacy(const V1_6::RttResponder& hidl_responder,
+                                     legacy_hal::wifi_rtt_responder* legacy_responder);
+bool convertHidlWifiChannelInfoToLegacy(const V1_6::WifiChannelInfo& hidl_info,
+                                        legacy_hal::wifi_channel_info* legacy_info);
+bool convertLegacyRttResponderToHidl(const legacy_hal::wifi_rtt_responder& legacy_responder,
+                                     V1_6::RttResponder* hidl_responder);
+bool convertLegacyRttCapabilitiesToHidl(
+        const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
+        V1_6::RttCapabilities* hidl_capabilities);
+bool convertLegacyVectorOfRttResultToHidl(
+        const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
+        std::vector<V1_6::RttResult>* hidl_results);
+uint32_t convertHidlWifiBandToLegacyMacBand(V1_5::WifiBand band);
+uint32_t convertHidlWifiIfaceModeToLegacy(uint32_t hidl_iface_mask);
+uint32_t convertHidlUsableChannelFilterToLegacy(uint32_t hidl_filter_mask);
+bool convertLegacyWifiUsableChannelsToHidl(
+        const std::vector<legacy_hal::wifi_usable_channel>& legacy_usable_channels,
+        std::vector<V1_6::WifiUsableChannel>* hidl_usable_channels);
+bool convertLegacyPeerInfoStatsToHidl(const legacy_hal::WifiPeerInfo& legacy_peer_info_stats,
+                                      V1_6::StaPeerInfo* hidl_peer_info_stats);
+bool convertLegacyWifiRateInfoToHidl(const legacy_hal::wifi_rate& legacy_rate,
+                                     V1_6::WifiRateInfo* hidl_rate);
+}  // namespace hidl_struct_util
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_STRUCT_UTIL_H_
diff --git a/wifi/aidl/default/aidl_sync_util.cpp b/wifi/1.6/default/hidl_sync_util.cpp
similarity index 78%
rename from wifi/aidl/default/aidl_sync_util.cpp
rename to wifi/1.6/default/hidl_sync_util.cpp
index d81eb81..358d95e 100644
--- a/wifi/aidl/default/aidl_sync_util.cpp
+++ b/wifi/1.6/default/hidl_sync_util.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,24 +14,26 @@
  * limitations under the License.
  */
 
-#include "aidl_sync_util.h"
+#include "hidl_sync_util.h"
 
 namespace {
 std::recursive_mutex g_mutex;
 }  // namespace
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
-namespace aidl_sync_util {
+namespace V1_6 {
+namespace implementation {
+namespace hidl_sync_util {
 
 std::unique_lock<std::recursive_mutex> acquireGlobalLock() {
     return std::unique_lock<std::recursive_mutex>{g_mutex};
 }
 
-}  // namespace aidl_sync_util
+}  // namespace hidl_sync_util
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/aidl_sync_util.h b/wifi/1.6/default/hidl_sync_util.h
similarity index 71%
rename from wifi/aidl/default/aidl_sync_util.h
rename to wifi/1.6/default/hidl_sync_util.h
index a61cd3f..2c1c37b 100644
--- a/wifi/aidl/default/aidl_sync_util.h
+++ b/wifi/1.6/default/hidl_sync_util.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,22 +14,24 @@
  * limitations under the License.
  */
 
-#ifndef AIDL_SYNC_UTIL_H_
-#define AIDL_SYNC_UTIL_H_
+#ifndef HIDL_SYNC_UTIL_H_
+#define HIDL_SYNC_UTIL_H_
 
 #include <mutex>
 
 // Utility that provides a global lock to synchronize access between
-// the AIDL thread and the legacy HAL's event loop.
-namespace aidl {
+// the HIDL thread and the legacy HAL's event loop.
 namespace android {
 namespace hardware {
 namespace wifi {
-namespace aidl_sync_util {
+namespace V1_6 {
+namespace implementation {
+namespace hidl_sync_util {
 std::unique_lock<std::recursive_mutex> acquireGlobalLock();
-}  // namespace aidl_sync_util
+}  // namespace hidl_sync_util
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
-#endif  // AIDL_SYNC_UTIL_H_
+#endif  // HIDL_SYNC_UTIL_H_
diff --git a/wifi/aidl/default/ringbuffer.cpp b/wifi/1.6/default/ringbuffer.cpp
similarity index 92%
rename from wifi/aidl/default/ringbuffer.cpp
rename to wifi/1.6/default/ringbuffer.cpp
index 9d08a73..981bf7b 100644
--- a/wifi/aidl/default/ringbuffer.cpp
+++ b/wifi/1.6/default/ringbuffer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,14 +14,15 @@
  * limitations under the License.
  */
 
-#include "ringbuffer.h"
-
 #include <android-base/logging.h>
 
-namespace aidl {
+#include "ringbuffer.h"
+
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 
 Ringbuffer::Ringbuffer(size_t maxSize) : size_(0), maxSize_(maxSize) {}
 
@@ -56,7 +57,8 @@
     size_ = 0;
 }
 
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/ringbuffer.h b/wifi/1.6/default/ringbuffer.h
similarity index 90%
rename from wifi/aidl/default/ringbuffer.h
rename to wifi/1.6/default/ringbuffer.h
index 80c0c11..c6a1e4c 100644
--- a/wifi/aidl/default/ringbuffer.h
+++ b/wifi/1.6/default/ringbuffer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,10 +20,11 @@
 #include <list>
 #include <vector>
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 
 /**
  * Ringbuffer object used to store debug data.
@@ -52,9 +53,10 @@
     size_t maxSize_;
 };
 
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
 
 #endif  // RINGBUFFER_H_
diff --git a/wifi/1.6/default/service.cpp b/wifi/1.6/default/service.cpp
new file mode 100644
index 0000000..c874d8b
--- /dev/null
+++ b/wifi/1.6/default/service.cpp
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <android-base/logging.h>
+#include <hidl/HidlLazyUtils.h>
+#include <hidl/HidlTransportSupport.h>
+#include <signal.h>
+#include <utils/Looper.h>
+#include <utils/StrongPointer.h>
+
+#include "wifi.h"
+#include "wifi_feature_flags.h"
+#include "wifi_legacy_hal.h"
+#include "wifi_legacy_hal_factory.h"
+#include "wifi_mode_controller.h"
+
+using android::hardware::configureRpcThreadpool;
+using android::hardware::joinRpcThreadpool;
+using android::hardware::LazyServiceRegistrar;
+using android::hardware::wifi::V1_6::implementation::feature_flags::WifiFeatureFlags;
+using android::hardware::wifi::V1_6::implementation::legacy_hal::WifiLegacyHal;
+using android::hardware::wifi::V1_6::implementation::legacy_hal::WifiLegacyHalFactory;
+using android::hardware::wifi::V1_6::implementation::mode_controller::WifiModeController;
+
+#ifdef LAZY_SERVICE
+const bool kLazyService = true;
+#else
+const bool kLazyService = false;
+#endif
+
+int main(int /*argc*/, char** argv) {
+    signal(SIGPIPE, SIG_IGN);
+    android::base::InitLogging(argv, android::base::LogdLogger(android::base::SYSTEM));
+    LOG(INFO) << "Wifi Hal is booting up...";
+
+    configureRpcThreadpool(1, true /* callerWillJoin */);
+
+    const auto iface_tool = std::make_shared<android::wifi_system::InterfaceTool>();
+    const auto legacy_hal_factory = std::make_shared<WifiLegacyHalFactory>(iface_tool);
+
+    // Setup hwbinder service
+    android::sp<android::hardware::wifi::V1_6::IWifi> service =
+            new android::hardware::wifi::V1_6::implementation::Wifi(
+                    iface_tool, legacy_hal_factory, std::make_shared<WifiModeController>(),
+                    std::make_shared<WifiFeatureFlags>());
+    if (kLazyService) {
+        auto registrar = LazyServiceRegistrar::getInstance();
+        CHECK_EQ(registrar.registerService(service), android::NO_ERROR)
+                << "Failed to register wifi HAL";
+    } else {
+        CHECK_EQ(service->registerAsService(), android::NO_ERROR) << "Failed to register wifi HAL";
+    }
+
+    joinRpcThreadpool();
+
+    LOG(INFO) << "Wifi Hal is terminating...";
+    return 0;
+}
diff --git a/wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp b/wifi/1.6/default/tests/hidl_struct_util_unit_tests.cpp
similarity index 69%
rename from wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp
rename to wifi/1.6/default/tests/hidl_struct_util_unit_tests.cpp
index 4a69c24..0dd0aa1 100644
--- a/wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp
+++ b/wifi/1.6/default/tests/hidl_struct_util_unit_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2017, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,7 +18,8 @@
 #include <android-base/macros.h>
 #include <gmock/gmock.h>
 
-#include "aidl_struct_util.h"
+#undef NAN
+#include "hidl_struct_util.h"
 
 using testing::Test;
 
@@ -30,15 +31,17 @@
 constexpr char kIfaceName1[] = "wlan0";
 constexpr char kIfaceName2[] = "wlan1";
 }  // namespace
-
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
+using namespace android::hardware::wifi::V1_0;
+using ::android::hardware::wifi::V1_6::WifiChannelWidthInMhz;
 
-class AidlStructUtilTest : public Test {};
+class HidlStructUtilTest : public Test {};
 
-TEST_F(AidlStructUtilTest, CanConvertLegacyWifiMacInfosToAidlWithOneMac) {
+TEST_F(HidlStructUtilTest, CanConvertLegacyWifiMacInfosToHidlWithOneMac) {
     std::vector<legacy_hal::WifiMacInfo> legacy_mac_infos;
     legacy_hal::WifiMacInfo legacy_mac_info1 = {
             .wlan_mac_id = kMacId1,
@@ -49,24 +52,24 @@
     legacy_mac_info1.iface_infos.push_back(legacy_iface_info2);
     legacy_mac_infos.push_back(legacy_mac_info1);
 
-    std::vector<IWifiChipEventCallback::RadioModeInfo> aidl_radio_mode_infos;
-    ASSERT_TRUE(aidl_struct_util::convertLegacyWifiMacInfosToAidl(legacy_mac_infos,
-                                                                  &aidl_radio_mode_infos));
+    std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo> hidl_radio_mode_infos;
+    ASSERT_TRUE(hidl_struct_util::convertLegacyWifiMacInfosToHidl(legacy_mac_infos,
+                                                                  &hidl_radio_mode_infos));
 
-    ASSERT_EQ(1u, aidl_radio_mode_infos.size());
-    auto aidl_radio_mode_info1 = aidl_radio_mode_infos[0];
-    EXPECT_EQ(legacy_mac_info1.wlan_mac_id, (uint32_t)aidl_radio_mode_info1.radioId);
-    EXPECT_EQ(WifiBand::BAND_24GHZ_5GHZ, aidl_radio_mode_info1.bandInfo);
-    ASSERT_EQ(2u, aidl_radio_mode_info1.ifaceInfos.size());
-    auto aidl_iface_info1 = aidl_radio_mode_info1.ifaceInfos[0];
-    EXPECT_EQ(legacy_iface_info1.name, aidl_iface_info1.name);
-    EXPECT_EQ(static_cast<int32_t>(legacy_iface_info1.channel), aidl_iface_info1.channel);
-    auto aidl_iface_info2 = aidl_radio_mode_info1.ifaceInfos[1];
-    EXPECT_EQ(legacy_iface_info2.name, aidl_iface_info2.name);
-    EXPECT_EQ(static_cast<int32_t>(legacy_iface_info2.channel), aidl_iface_info2.channel);
+    ASSERT_EQ(1u, hidl_radio_mode_infos.size());
+    auto hidl_radio_mode_info1 = hidl_radio_mode_infos[0];
+    EXPECT_EQ(legacy_mac_info1.wlan_mac_id, hidl_radio_mode_info1.radioId);
+    EXPECT_EQ(V1_4::WifiBand::BAND_24GHZ_5GHZ, hidl_radio_mode_info1.bandInfo);
+    ASSERT_EQ(2u, hidl_radio_mode_info1.ifaceInfos.size());
+    auto hidl_iface_info1 = hidl_radio_mode_info1.ifaceInfos[0];
+    EXPECT_EQ(legacy_iface_info1.name, hidl_iface_info1.name);
+    EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info1.channel), hidl_iface_info1.channel);
+    auto hidl_iface_info2 = hidl_radio_mode_info1.ifaceInfos[1];
+    EXPECT_EQ(legacy_iface_info2.name, hidl_iface_info2.name);
+    EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info2.channel), hidl_iface_info2.channel);
 }
 
-TEST_F(AidlStructUtilTest, CanConvertLegacyWifiMacInfosToAidlWithTwoMac) {
+TEST_F(HidlStructUtilTest, CanConvertLegacyWifiMacInfosToHidlWithTwoMac) {
     std::vector<legacy_hal::WifiMacInfo> legacy_mac_infos;
     legacy_hal::WifiMacInfo legacy_mac_info1 = {.wlan_mac_id = kMacId1,
                                                 .mac_band = legacy_hal::WLAN_MAC_5_0_BAND};
@@ -79,40 +82,40 @@
     legacy_mac_info2.iface_infos.push_back(legacy_iface_info2);
     legacy_mac_infos.push_back(legacy_mac_info2);
 
-    std::vector<IWifiChipEventCallback::RadioModeInfo> aidl_radio_mode_infos;
-    ASSERT_TRUE(aidl_struct_util::convertLegacyWifiMacInfosToAidl(legacy_mac_infos,
-                                                                  &aidl_radio_mode_infos));
+    std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo> hidl_radio_mode_infos;
+    ASSERT_TRUE(hidl_struct_util::convertLegacyWifiMacInfosToHidl(legacy_mac_infos,
+                                                                  &hidl_radio_mode_infos));
 
-    ASSERT_EQ(2u, aidl_radio_mode_infos.size());
+    ASSERT_EQ(2u, hidl_radio_mode_infos.size());
 
     // Find mac info 1.
-    const auto aidl_radio_mode_info1 =
-            std::find_if(aidl_radio_mode_infos.begin(), aidl_radio_mode_infos.end(),
-                         [&legacy_mac_info1](const IWifiChipEventCallback::RadioModeInfo& x) {
-                             return (uint32_t)x.radioId == legacy_mac_info1.wlan_mac_id;
+    const auto hidl_radio_mode_info1 =
+            std::find_if(hidl_radio_mode_infos.begin(), hidl_radio_mode_infos.end(),
+                         [&legacy_mac_info1](const V1_4::IWifiChipEventCallback::RadioModeInfo& x) {
+                             return x.radioId == legacy_mac_info1.wlan_mac_id;
                          });
-    ASSERT_NE(aidl_radio_mode_infos.end(), aidl_radio_mode_info1);
-    EXPECT_EQ(WifiBand::BAND_5GHZ, aidl_radio_mode_info1->bandInfo);
-    ASSERT_EQ(1u, aidl_radio_mode_info1->ifaceInfos.size());
-    auto aidl_iface_info1 = aidl_radio_mode_info1->ifaceInfos[0];
-    EXPECT_EQ(legacy_iface_info1.name, aidl_iface_info1.name);
-    EXPECT_EQ(static_cast<int32_t>(legacy_iface_info1.channel), aidl_iface_info1.channel);
+    ASSERT_NE(hidl_radio_mode_infos.end(), hidl_radio_mode_info1);
+    EXPECT_EQ(V1_4::WifiBand::BAND_5GHZ, hidl_radio_mode_info1->bandInfo);
+    ASSERT_EQ(1u, hidl_radio_mode_info1->ifaceInfos.size());
+    auto hidl_iface_info1 = hidl_radio_mode_info1->ifaceInfos[0];
+    EXPECT_EQ(legacy_iface_info1.name, hidl_iface_info1.name);
+    EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info1.channel), hidl_iface_info1.channel);
 
     // Find mac info 2.
-    const auto aidl_radio_mode_info2 =
-            std::find_if(aidl_radio_mode_infos.begin(), aidl_radio_mode_infos.end(),
-                         [&legacy_mac_info2](const IWifiChipEventCallback::RadioModeInfo& x) {
-                             return (uint32_t)x.radioId == legacy_mac_info2.wlan_mac_id;
+    const auto hidl_radio_mode_info2 =
+            std::find_if(hidl_radio_mode_infos.begin(), hidl_radio_mode_infos.end(),
+                         [&legacy_mac_info2](const V1_4::IWifiChipEventCallback::RadioModeInfo& x) {
+                             return x.radioId == legacy_mac_info2.wlan_mac_id;
                          });
-    ASSERT_NE(aidl_radio_mode_infos.end(), aidl_radio_mode_info2);
-    EXPECT_EQ(WifiBand::BAND_24GHZ, aidl_radio_mode_info2->bandInfo);
-    ASSERT_EQ(1u, aidl_radio_mode_info2->ifaceInfos.size());
-    auto aidl_iface_info2 = aidl_radio_mode_info2->ifaceInfos[0];
-    EXPECT_EQ(legacy_iface_info2.name, aidl_iface_info2.name);
-    EXPECT_EQ(static_cast<int32_t>(legacy_iface_info2.channel), aidl_iface_info2.channel);
+    ASSERT_NE(hidl_radio_mode_infos.end(), hidl_radio_mode_info2);
+    EXPECT_EQ(V1_4::WifiBand::BAND_24GHZ, hidl_radio_mode_info2->bandInfo);
+    ASSERT_EQ(1u, hidl_radio_mode_info2->ifaceInfos.size());
+    auto hidl_iface_info2 = hidl_radio_mode_info2->ifaceInfos[0];
+    EXPECT_EQ(legacy_iface_info2.name, hidl_iface_info2.name);
+    EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info2.channel), hidl_iface_info2.channel);
 }
 
-TEST_F(AidlStructUtilTest, canConvertLegacyLinkLayerStatsToAidl) {
+TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
     legacy_hal::LinkLayerStats legacy_stats{};
     legacy_stats.radios.push_back(legacy_hal::LinkLayerRadioStats{});
     legacy_stats.radios.push_back(legacy_hal::LinkLayerRadioStats{});
@@ -213,77 +216,77 @@
         peer.rate_stats.push_back(rate_stat2);
     }
 
-    StaLinkLayerStats converted{};
-    aidl_struct_util::convertLegacyLinkLayerStatsToAidl(legacy_stats, &converted);
-    EXPECT_EQ(legacy_stats.iface.beacon_rx, (uint32_t)converted.iface.beaconRx);
-    EXPECT_EQ(legacy_stats.iface.rssi_mgmt, converted.iface.avgRssiMgmt);
+    V1_6::StaLinkLayerStats converted{};
+    hidl_struct_util::convertLegacyLinkLayerStatsToHidl(legacy_stats, &converted);
+    EXPECT_EQ(legacy_stats.iface.beacon_rx, converted.iface.V1_0.beaconRx);
+    EXPECT_EQ(legacy_stats.iface.rssi_mgmt, converted.iface.V1_0.avgRssiMgmt);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu,
-              converted.iface.wmeBePktStats.rxMpdu);
+              converted.iface.V1_0.wmeBePktStats.rxMpdu);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu,
-              converted.iface.wmeBePktStats.txMpdu);
+              converted.iface.V1_0.wmeBePktStats.txMpdu);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost,
-              converted.iface.wmeBePktStats.lostMpdu);
+              converted.iface.V1_0.wmeBePktStats.lostMpdu);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries,
-              converted.iface.wmeBePktStats.retries);
+              converted.iface.V1_0.wmeBePktStats.retries);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_min,
-              (uint32_t)converted.iface.wmeBeContentionTimeStats.contentionTimeMinInUsec);
+              converted.iface.wmeBeContentionTimeStats.contentionTimeMinInUsec);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_max,
-              (uint32_t)converted.iface.wmeBeContentionTimeStats.contentionTimeMaxInUsec);
+              converted.iface.wmeBeContentionTimeStats.contentionTimeMaxInUsec);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_avg,
-              (uint32_t)converted.iface.wmeBeContentionTimeStats.contentionTimeAvgInUsec);
+              converted.iface.wmeBeContentionTimeStats.contentionTimeAvgInUsec);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples,
-              (uint32_t)converted.iface.wmeBeContentionTimeStats.contentionNumSamples);
+              converted.iface.wmeBeContentionTimeStats.contentionNumSamples);
 
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu,
-              converted.iface.wmeBkPktStats.rxMpdu);
+              converted.iface.V1_0.wmeBkPktStats.rxMpdu);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu,
-              converted.iface.wmeBkPktStats.txMpdu);
+              converted.iface.V1_0.wmeBkPktStats.txMpdu);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost,
-              converted.iface.wmeBkPktStats.lostMpdu);
+              converted.iface.V1_0.wmeBkPktStats.lostMpdu);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries,
-              converted.iface.wmeBkPktStats.retries);
+              converted.iface.V1_0.wmeBkPktStats.retries);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_min,
-              (uint32_t)converted.iface.wmeBkContentionTimeStats.contentionTimeMinInUsec);
+              converted.iface.wmeBkContentionTimeStats.contentionTimeMinInUsec);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_max,
-              (uint32_t)converted.iface.wmeBkContentionTimeStats.contentionTimeMaxInUsec);
+              converted.iface.wmeBkContentionTimeStats.contentionTimeMaxInUsec);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_avg,
-              (uint32_t)converted.iface.wmeBkContentionTimeStats.contentionTimeAvgInUsec);
+              converted.iface.wmeBkContentionTimeStats.contentionTimeAvgInUsec);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples,
-              (uint32_t)converted.iface.wmeBkContentionTimeStats.contentionNumSamples);
+              converted.iface.wmeBkContentionTimeStats.contentionNumSamples);
 
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu,
-              converted.iface.wmeViPktStats.rxMpdu);
+              converted.iface.V1_0.wmeViPktStats.rxMpdu);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu,
-              converted.iface.wmeViPktStats.txMpdu);
+              converted.iface.V1_0.wmeViPktStats.txMpdu);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost,
-              converted.iface.wmeViPktStats.lostMpdu);
+              converted.iface.V1_0.wmeViPktStats.lostMpdu);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries,
-              converted.iface.wmeViPktStats.retries);
+              converted.iface.V1_0.wmeViPktStats.retries);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_min,
-              (uint32_t)converted.iface.wmeViContentionTimeStats.contentionTimeMinInUsec);
+              converted.iface.wmeViContentionTimeStats.contentionTimeMinInUsec);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_max,
-              (uint32_t)converted.iface.wmeViContentionTimeStats.contentionTimeMaxInUsec);
+              converted.iface.wmeViContentionTimeStats.contentionTimeMaxInUsec);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_avg,
-              (uint32_t)converted.iface.wmeViContentionTimeStats.contentionTimeAvgInUsec);
+              converted.iface.wmeViContentionTimeStats.contentionTimeAvgInUsec);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples,
-              (uint32_t)converted.iface.wmeViContentionTimeStats.contentionNumSamples);
+              converted.iface.wmeViContentionTimeStats.contentionNumSamples);
 
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu,
-              converted.iface.wmeVoPktStats.rxMpdu);
+              converted.iface.V1_0.wmeVoPktStats.rxMpdu);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu,
-              converted.iface.wmeVoPktStats.txMpdu);
+              converted.iface.V1_0.wmeVoPktStats.txMpdu);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost,
-              converted.iface.wmeVoPktStats.lostMpdu);
+              converted.iface.V1_0.wmeVoPktStats.lostMpdu);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries,
-              converted.iface.wmeVoPktStats.retries);
+              converted.iface.V1_0.wmeVoPktStats.retries);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_min,
-              (uint32_t)converted.iface.wmeVoContentionTimeStats.contentionTimeMinInUsec);
+              converted.iface.wmeVoContentionTimeStats.contentionTimeMinInUsec);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_max,
-              (uint32_t)converted.iface.wmeVoContentionTimeStats.contentionTimeMaxInUsec);
+              converted.iface.wmeVoContentionTimeStats.contentionTimeMaxInUsec);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_avg,
-              (uint32_t)converted.iface.wmeVoContentionTimeStats.contentionTimeAvgInUsec);
+              converted.iface.wmeVoContentionTimeStats.contentionTimeAvgInUsec);
     EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples,
-              (uint32_t)converted.iface.wmeVoContentionTimeStats.contentionNumSamples);
+              converted.iface.wmeVoContentionTimeStats.contentionNumSamples);
 
     EXPECT_EQ(legacy_stats.iface.info.time_slicing_duty_cycle_percent,
               converted.iface.timeSliceDutyCycleInPercent);
@@ -291,43 +294,42 @@
     EXPECT_EQ(legacy_stats.radios.size(), converted.radios.size());
     for (size_t i = 0; i < legacy_stats.radios.size(); i++) {
         EXPECT_EQ(legacy_stats.radios[i].stats.radio, converted.radios[i].radioId);
-        EXPECT_EQ(legacy_stats.radios[i].stats.on_time, (uint32_t)converted.radios[i].onTimeInMs);
-        EXPECT_EQ(legacy_stats.radios[i].stats.tx_time, (uint32_t)converted.radios[i].txTimeInMs);
-        EXPECT_EQ(legacy_stats.radios[i].stats.rx_time, (uint32_t)converted.radios[i].rxTimeInMs);
+        EXPECT_EQ(legacy_stats.radios[i].stats.on_time, converted.radios[i].V1_0.onTimeInMs);
+        EXPECT_EQ(legacy_stats.radios[i].stats.tx_time, converted.radios[i].V1_0.txTimeInMs);
+        EXPECT_EQ(legacy_stats.radios[i].stats.rx_time, converted.radios[i].V1_0.rxTimeInMs);
         EXPECT_EQ(legacy_stats.radios[i].stats.on_time_scan,
-                  (uint32_t)converted.radios[i].onTimeInMsForScan);
+                  converted.radios[i].V1_0.onTimeInMsForScan);
         EXPECT_EQ(legacy_stats.radios[i].tx_time_per_levels.size(),
-                  converted.radios[i].txTimeInMsPerLevel.size());
+                  converted.radios[i].V1_0.txTimeInMsPerLevel.size());
         for (size_t j = 0; j < legacy_stats.radios[i].tx_time_per_levels.size(); j++) {
             EXPECT_EQ(legacy_stats.radios[i].tx_time_per_levels[j],
-                      (uint32_t)converted.radios[i].txTimeInMsPerLevel[j]);
+                      converted.radios[i].V1_0.txTimeInMsPerLevel[j]);
         }
         EXPECT_EQ(legacy_stats.radios[i].stats.on_time_nbd,
-                  (uint32_t)converted.radios[i].onTimeInMsForNanScan);
+                  converted.radios[i].onTimeInMsForNanScan);
         EXPECT_EQ(legacy_stats.radios[i].stats.on_time_gscan,
-                  (uint32_t)converted.radios[i].onTimeInMsForBgScan);
+                  converted.radios[i].onTimeInMsForBgScan);
         EXPECT_EQ(legacy_stats.radios[i].stats.on_time_roam_scan,
-                  (uint32_t)converted.radios[i].onTimeInMsForRoamScan);
+                  converted.radios[i].onTimeInMsForRoamScan);
         EXPECT_EQ(legacy_stats.radios[i].stats.on_time_pno_scan,
-                  (uint32_t)converted.radios[i].onTimeInMsForPnoScan);
+                  converted.radios[i].onTimeInMsForPnoScan);
         EXPECT_EQ(legacy_stats.radios[i].stats.on_time_hs20,
-                  (uint32_t)converted.radios[i].onTimeInMsForHs20Scan);
+                  converted.radios[i].onTimeInMsForHs20Scan);
         EXPECT_EQ(legacy_stats.radios[i].channel_stats.size(),
                   converted.radios[i].channelStats.size());
         for (size_t k = 0; k < legacy_stats.radios[i].channel_stats.size(); k++) {
             auto& legacy_channel_st = legacy_stats.radios[i].channel_stats[k];
             EXPECT_EQ(WifiChannelWidthInMhz::WIDTH_20,
                       converted.radios[i].channelStats[k].channel.width);
-            EXPECT_EQ(legacy_channel_st.channel.center_freq,
+            EXPECT_EQ(WifiChannelInMhz(legacy_channel_st.channel.center_freq),
                       converted.radios[i].channelStats[k].channel.centerFreq);
-            EXPECT_EQ(legacy_channel_st.channel.center_freq0,
+            EXPECT_EQ(WifiChannelInMhz(legacy_channel_st.channel.center_freq0),
                       converted.radios[i].channelStats[k].channel.centerFreq0);
-            EXPECT_EQ(legacy_channel_st.channel.center_freq1,
+            EXPECT_EQ(WifiChannelInMhz(legacy_channel_st.channel.center_freq1),
                       converted.radios[i].channelStats[k].channel.centerFreq1);
             EXPECT_EQ(legacy_channel_st.cca_busy_time,
-                      (uint32_t)converted.radios[i].channelStats[k].ccaBusyTimeInMs);
-            EXPECT_EQ(legacy_channel_st.on_time,
-                      (uint32_t)converted.radios[i].channelStats[k].onTimeInMs);
+                      converted.radios[i].channelStats[k].ccaBusyTimeInMs);
+            EXPECT_EQ(legacy_channel_st.on_time, converted.radios[i].channelStats[k].onTimeInMs);
         }
     }
 
@@ -345,36 +347,35 @@
             EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rate.bw,
                       (uint32_t)converted.iface.peers[i].rateStats[j].rateInfo.bw);
             EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rate.rateMcsIdx,
-                      (uint32_t)converted.iface.peers[i].rateStats[j].rateInfo.rateMcsIdx);
+                      converted.iface.peers[i].rateStats[j].rateInfo.rateMcsIdx);
             EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].tx_mpdu,
-                      (uint32_t)converted.iface.peers[i].rateStats[j].txMpdu);
+                      converted.iface.peers[i].rateStats[j].txMpdu);
             EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rx_mpdu,
-                      (uint32_t)converted.iface.peers[i].rateStats[j].rxMpdu);
+                      converted.iface.peers[i].rateStats[j].rxMpdu);
             EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].mpdu_lost,
-                      (uint32_t)converted.iface.peers[i].rateStats[j].mpduLost);
+                      converted.iface.peers[i].rateStats[j].mpduLost);
             EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].retries,
-                      (uint32_t)converted.iface.peers[i].rateStats[j].retries);
+                      converted.iface.peers[i].rateStats[j].retries);
         }
     }
 }
 
-TEST_F(AidlStructUtilTest, CanConvertLegacyFeaturesToAidl) {
-    using AidlChipCaps = IWifiChip::ChipCapabilityMask;
+TEST_F(HidlStructUtilTest, CanConvertLegacyFeaturesToHidl) {
+    using HidlChipCaps = V1_3::IWifiChip::ChipCapabilityMask;
 
-    uint32_t aidl_caps;
+    uint32_t hidle_caps;
 
     uint32_t legacy_feature_set = WIFI_FEATURE_D2D_RTT | WIFI_FEATURE_SET_LATENCY_MODE;
     uint32_t legacy_logger_feature_set = legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED;
 
-    ASSERT_TRUE(aidl_struct_util::convertLegacyFeaturesToAidlChipCapabilities(
-            legacy_feature_set, legacy_logger_feature_set, &aidl_caps));
+    ASSERT_TRUE(hidl_struct_util::convertLegacyFeaturesToHidlChipCapabilities(
+            legacy_feature_set, legacy_logger_feature_set, &hidle_caps));
 
-    EXPECT_EQ((uint32_t)AidlChipCaps::DEBUG_RING_BUFFER_VENDOR_DATA |
-                      (uint32_t)AidlChipCaps::DEBUG_HOST_WAKE_REASON_STATS |
-                      (uint32_t)AidlChipCaps::DEBUG_ERROR_ALERTS | (uint32_t)AidlChipCaps::D2D_RTT |
-                      (uint32_t)AidlChipCaps::SET_LATENCY_MODE |
-                      (uint32_t)AidlChipCaps::DEBUG_MEMORY_DRIVER_DUMP,
-              aidl_caps);
+    EXPECT_EQ(HidlChipCaps::DEBUG_RING_BUFFER_VENDOR_DATA |
+                      HidlChipCaps::DEBUG_HOST_WAKE_REASON_STATS |
+                      HidlChipCaps::DEBUG_ERROR_ALERTS | HidlChipCaps::D2D_RTT |
+                      HidlChipCaps::SET_LATENCY_MODE | HidlChipCaps::DEBUG_MEMORY_DRIVER_DUMP,
+              hidle_caps);
 }
 
 void insertRadioCombination(legacy_hal::wifi_radio_combination* dst_radio_combination_ptr,
@@ -389,16 +390,16 @@
                             legacy_hal::wifi_radio_configuration* radio_configuration) {
     EXPECT_EQ(num_radio_configurations, radioCombination->radioConfigurations.size());
     for (size_t i = 0; i < num_radio_configurations; i++) {
-        EXPECT_EQ(aidl_struct_util::convertLegacyMacBandToAidlWifiBand(radio_configuration->band),
+        EXPECT_EQ(hidl_struct_util::convertLegacyMacBandToHidlWifiBand(radio_configuration->band),
                   radioCombination->radioConfigurations[i].bandInfo);
-        EXPECT_EQ(aidl_struct_util::convertLegacyAntennaConfigurationToAidl(
+        EXPECT_EQ(hidl_struct_util::convertLegacyAntennaConfigurationToHidl(
                           radio_configuration->antenna_cfg),
                   radioCombination->radioConfigurations[i].antennaMode);
         radio_configuration++;
     }
 }
 
-TEST_F(AidlStructUtilTest, canConvertLegacyRadioCombinationsMatrixToAidl) {
+TEST_F(HidlStructUtilTest, canConvertLegacyRadioCombinationsMatrixToHidl) {
     legacy_hal::wifi_radio_configuration radio_configurations_array1[] = {
             {.band = legacy_hal::WLAN_MAC_2_4_BAND, .antenna_cfg = legacy_hal::WIFI_ANTENNA_1X1},
     };
@@ -460,8 +461,8 @@
             sizeof(radio_configurations_array3) / sizeof(radio_configurations_array3[0]),
             radio_configurations_array3);
 
-    WifiRadioCombinationMatrix converted_matrix{};
-    aidl_struct_util::convertLegacyRadioCombinationsMatrixToAidl(legacy_matrix, &converted_matrix);
+    V1_6::WifiRadioCombinationMatrix converted_matrix{};
+    hidl_struct_util::convertLegacyRadioCombinationsMatrixToHidl(legacy_matrix, &converted_matrix);
 
     // Verify the conversion
     EXPECT_EQ(legacy_matrix->num_radio_combinations, converted_matrix.radioCombinations.size());
@@ -478,8 +479,8 @@
             sizeof(radio_configurations_array3) / sizeof(radio_configurations_array3[0]),
             radio_configurations_array3);
 }
-
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/tests/main.cpp b/wifi/1.6/default/tests/main.cpp
similarity index 94%
rename from wifi/aidl/default/tests/main.cpp
rename to wifi/1.6/default/tests/main.cpp
index 767422c..9aac837 100644
--- a/wifi/aidl/default/tests/main.cpp
+++ b/wifi/1.6/default/tests/main.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/wifi/aidl/default/tests/mock_interface_tool.cpp b/wifi/1.6/default/tests/mock_interface_tool.cpp
similarity index 86%
rename from wifi/aidl/default/tests/mock_interface_tool.cpp
rename to wifi/1.6/default/tests/mock_interface_tool.cpp
index 79f3d1e..b99a164 100644
--- a/wifi/aidl/default/tests/mock_interface_tool.cpp
+++ b/wifi/1.6/default/tests/mock_interface_tool.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,6 +17,7 @@
 #include <android-base/macros.h>
 #include <gmock/gmock.h>
 
+#undef NAN  // This is weird, NAN is defined in bionic/libc/include/math.h:38
 #include "mock_interface_tool.h"
 
 namespace android {
diff --git a/wifi/aidl/default/tests/mock_interface_tool.h b/wifi/1.6/default/tests/mock_interface_tool.h
similarity index 95%
rename from wifi/aidl/default/tests/mock_interface_tool.h
rename to wifi/1.6/default/tests/mock_interface_tool.h
index 9795de8..7ce3992 100644
--- a/wifi/aidl/default/tests/mock_interface_tool.h
+++ b/wifi/1.6/default/tests/mock_interface_tool.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/wifi/aidl/default/tests/mock_wifi_feature_flags.cpp b/wifi/1.6/default/tests/mock_wifi_feature_flags.cpp
similarity index 85%
rename from wifi/aidl/default/tests/mock_wifi_feature_flags.cpp
rename to wifi/1.6/default/tests/mock_wifi_feature_flags.cpp
index 0c4e59d..d10b74c 100644
--- a/wifi/aidl/default/tests/mock_wifi_feature_flags.cpp
+++ b/wifi/1.6/default/tests/mock_wifi_feature_flags.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,16 +18,18 @@
 
 #include "mock_wifi_feature_flags.h"
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace feature_flags {
 
 MockWifiFeatureFlags::MockWifiFeatureFlags() {}
 
 }  // namespace feature_flags
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/tests/mock_wifi_feature_flags.h b/wifi/1.6/default/tests/mock_wifi_feature_flags.h
similarity index 77%
rename from wifi/aidl/default/tests/mock_wifi_feature_flags.h
rename to wifi/1.6/default/tests/mock_wifi_feature_flags.h
index 9143d15..fbe1f7a 100644
--- a/wifi/aidl/default/tests/mock_wifi_feature_flags.h
+++ b/wifi/1.6/default/tests/mock_wifi_feature_flags.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,27 +18,30 @@
 #define MOCK_WIFI_FEATURE_FLAGS_H_
 
 #include <gmock/gmock.h>
+#undef NAN  // This is weird, NAN is defined in bionic/libc/include/math.h:38
 
 #include "wifi_feature_flags.h"
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace feature_flags {
 
 class MockWifiFeatureFlags : public WifiFeatureFlags {
   public:
     MockWifiFeatureFlags();
 
-    MOCK_METHOD1(getChipModes, std::vector<IWifiChip::ChipMode>(bool is_primary));
+    MOCK_METHOD1(getChipModes, std::vector<V1_6::IWifiChip::ChipMode>(bool is_primary));
     MOCK_METHOD0(isApMacRandomizationDisabled, bool());
 };
 
 }  // namespace feature_flags
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
 
 #endif  // MOCK_WIFI_FEATURE_FLAGS_H_
diff --git a/wifi/aidl/default/tests/mock_wifi_iface_util.cpp b/wifi/1.6/default/tests/mock_wifi_iface_util.cpp
similarity index 68%
rename from wifi/aidl/default/tests/mock_wifi_iface_util.cpp
rename to wifi/1.6/default/tests/mock_wifi_iface_util.cpp
index 0f787f2..24b16cb 100644
--- a/wifi/aidl/default/tests/mock_wifi_iface_util.cpp
+++ b/wifi/1.6/default/tests/mock_wifi_iface_util.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,21 +18,22 @@
 #include <android-base/macros.h>
 #include <gmock/gmock.h>
 
+#undef NAN  // This is weird, NAN is defined in bionic/libc/include/math.h:38
 #include "mock_wifi_iface_util.h"
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace iface_util {
 
-MockWifiIfaceUtil::MockWifiIfaceUtil(
-        const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
-        const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
+MockWifiIfaceUtil::MockWifiIfaceUtil(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
+                                     const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
     : WifiIfaceUtil(iface_tool, legacy_hal) {}
-
 }  // namespace iface_util
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/tests/mock_wifi_iface_util.h b/wifi/1.6/default/tests/mock_wifi_iface_util.h
similarity index 79%
rename from wifi/aidl/default/tests/mock_wifi_iface_util.h
rename to wifi/1.6/default/tests/mock_wifi_iface_util.h
index 49a8636..2701c36 100644
--- a/wifi/aidl/default/tests/mock_wifi_iface_util.h
+++ b/wifi/1.6/default/tests/mock_wifi_iface_util.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,30 +21,30 @@
 
 #include "wifi_iface_util.h"
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace iface_util {
 
-class MockWifiIfaceUtil : public iface_util::WifiIfaceUtil {
+class MockWifiIfaceUtil : public WifiIfaceUtil {
   public:
-    MockWifiIfaceUtil(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
+    MockWifiIfaceUtil(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
                       const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
     MOCK_METHOD1(getFactoryMacAddress, std::array<uint8_t, 6>(const std::string&));
     MOCK_METHOD2(setMacAddress, bool(const std::string&, const std::array<uint8_t, 6>&));
     MOCK_METHOD0(getOrCreateRandomMacAddress, std::array<uint8_t, 6>());
-    MOCK_METHOD2(registerIfaceEventHandlers,
-                 void(const std::string&, iface_util::IfaceEventHandlers));
+    MOCK_METHOD2(registerIfaceEventHandlers, void(const std::string&, IfaceEventHandlers));
     MOCK_METHOD1(unregisterIfaceEventHandlers, void(const std::string&));
     MOCK_METHOD2(setUpState, bool(const std::string&, bool));
     MOCK_METHOD1(ifNameToIndex, unsigned(const std::string&));
 };
-
 }  // namespace iface_util
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
 
 #endif  // MOCK_WIFI_IFACE_UTIL_H_
diff --git a/wifi/aidl/default/tests/mock_wifi_legacy_hal.cpp b/wifi/1.6/default/tests/mock_wifi_legacy_hal.cpp
similarity index 69%
rename from wifi/aidl/default/tests/mock_wifi_legacy_hal.cpp
rename to wifi/1.6/default/tests/mock_wifi_legacy_hal.cpp
index 33b2b1c..2c55861 100644
--- a/wifi/aidl/default/tests/mock_wifi_legacy_hal.cpp
+++ b/wifi/1.6/default/tests/mock_wifi_legacy_hal.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,20 +18,22 @@
 #include <android-base/macros.h>
 #include <gmock/gmock.h>
 
+#undef NAN  // This is weird, NAN is defined in bionic/libc/include/math.h:38
 #include "mock_wifi_legacy_hal.h"
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace legacy_hal {
 
-MockWifiLegacyHal::MockWifiLegacyHal(
-        const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
-        const wifi_hal_fn& fn, bool is_primary)
+MockWifiLegacyHal::MockWifiLegacyHal(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
+                                     const wifi_hal_fn& fn, bool is_primary)
     : WifiLegacyHal(iface_tool, fn, is_primary) {}
 }  // namespace legacy_hal
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/tests/mock_wifi_legacy_hal.h b/wifi/1.6/default/tests/mock_wifi_legacy_hal.h
similarity index 92%
rename from wifi/aidl/default/tests/mock_wifi_legacy_hal.h
rename to wifi/1.6/default/tests/mock_wifi_legacy_hal.h
index 28129a9..85dbf0f 100644
--- a/wifi/aidl/default/tests/mock_wifi_legacy_hal.h
+++ b/wifi/1.6/default/tests/mock_wifi_legacy_hal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,15 +21,16 @@
 
 #include "wifi_legacy_hal.h"
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace legacy_hal {
 
 class MockWifiLegacyHal : public WifiLegacyHal {
   public:
-    MockWifiLegacyHal(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
+    MockWifiLegacyHal(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
                       const wifi_hal_fn& fn, bool is_primary);
     MOCK_METHOD0(initialize, wifi_error());
     MOCK_METHOD0(start, wifi_error());
@@ -61,9 +62,10 @@
     MOCK_METHOD1(getSupportedFeatureSet, std::pair<wifi_error, uint64_t>(const std::string&));
 };
 }  // namespace legacy_hal
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
 
 #endif  // MOCK_WIFI_LEGACY_HAL_H_
diff --git a/wifi/aidl/default/tests/mock_wifi_mode_controller.cpp b/wifi/1.6/default/tests/mock_wifi_mode_controller.cpp
similarity index 87%
rename from wifi/aidl/default/tests/mock_wifi_mode_controller.cpp
rename to wifi/1.6/default/tests/mock_wifi_mode_controller.cpp
index f4cc4c4..446f829 100644
--- a/wifi/aidl/default/tests/mock_wifi_mode_controller.cpp
+++ b/wifi/1.6/default/tests/mock_wifi_mode_controller.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,16 +21,17 @@
 #undef NAN  // This is weird, NAN is defined in bionic/libc/include/math.h:38
 #include "mock_wifi_mode_controller.h"
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace mode_controller {
 
 MockWifiModeController::MockWifiModeController() : WifiModeController() {}
-
 }  // namespace mode_controller
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/tests/mock_wifi_mode_controller.h b/wifi/1.6/default/tests/mock_wifi_mode_controller.h
similarity index 88%
rename from wifi/aidl/default/tests/mock_wifi_mode_controller.h
rename to wifi/1.6/default/tests/mock_wifi_mode_controller.h
index f77f7d0..addcc81 100644
--- a/wifi/aidl/default/tests/mock_wifi_mode_controller.h
+++ b/wifi/1.6/default/tests/mock_wifi_mode_controller.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,10 +21,11 @@
 
 #include "wifi_mode_controller.h"
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace mode_controller {
 
 class MockWifiModeController : public WifiModeController {
@@ -36,9 +37,10 @@
     MOCK_METHOD0(deinitialize, bool());
 };
 }  // namespace mode_controller
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
 
 #endif  // MOCK_WIFI_MODE_CONTROLLER_H_
diff --git a/wifi/aidl/default/tests/ringbuffer_unit_tests.cpp b/wifi/1.6/default/tests/ringbuffer_unit_tests.cpp
similarity index 94%
rename from wifi/aidl/default/tests/ringbuffer_unit_tests.cpp
rename to wifi/1.6/default/tests/ringbuffer_unit_tests.cpp
index c257100..eb86194 100644
--- a/wifi/aidl/default/tests/ringbuffer_unit_tests.cpp
+++ b/wifi/1.6/default/tests/ringbuffer_unit_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2018, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,10 +21,11 @@
 using testing::Return;
 using testing::Test;
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 
 class RingbufferTest : public Test {
   public:
@@ -89,8 +90,8 @@
     ASSERT_EQ(1u, buffer_.getData().size());
     EXPECT_EQ(input, buffer_.getData().front());
 }
-
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/tests/runtests.sh b/wifi/1.6/default/tests/runtests.sh
similarity index 79%
rename from wifi/aidl/default/tests/runtests.sh
rename to wifi/1.6/default/tests/runtests.sh
index 1f53ab8..6bce3ef 100755
--- a/wifi/aidl/default/tests/runtests.sh
+++ b/wifi/1.6/default/tests/runtests.sh
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-# Copyright(C) 2022 The Android Open Source Project
+# Copyright(C) 2017 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0(the "License");
 # you may not use this file except in compliance with the License.
@@ -20,7 +20,7 @@
 fi
 set -e
 
-$ANDROID_BUILD_TOP/build/soong/soong_ui.bash --make-mode android.hardware.wifi-service-tests
+$ANDROID_BUILD_TOP/build/soong/soong_ui.bash --make-mode android.hardware.wifi@1.0-service-tests
 adb root
 adb sync data
-adb shell /data/nativetest64/vendor/android.hardware.wifi-service-tests/android.hardware.wifi-service-tests
+adb shell /data/nativetest64/vendor/android.hardware.wifi@1.0-service-tests/android.hardware.wifi@1.0-service-tests
diff --git a/wifi/aidl/default/tests/wifi_chip_unit_tests.cpp b/wifi/1.6/default/tests/wifi_chip_unit_tests.cpp
similarity index 66%
rename from wifi/aidl/default/tests/wifi_chip_unit_tests.cpp
rename to wifi/1.6/default/tests/wifi_chip_unit_tests.cpp
index e66b650..81117c5 100644
--- a/wifi/aidl/default/tests/wifi_chip_unit_tests.cpp
+++ b/wifi/1.6/default/tests/wifi_chip_unit_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2017, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@
 #include <cutils/properties.h>
 #include <gmock/gmock.h>
 
+#undef NAN  // This is weird, NAN is defined in bionic/libc/include/math.h:38
 #include "wifi_chip.h"
 
 #include "mock_interface_tool.h"
@@ -32,38 +33,28 @@
 using testing::Test;
 
 namespace {
-constexpr int kFakeChipId = 5;
+using android::hardware::wifi::V1_0::ChipId;
+
+constexpr ChipId kFakeChipId = 5;
 }  // namespace
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 
 class WifiChipTest : public Test {
   protected:
     void setupV1IfaceCombination() {
         // clang-format off
-		// 1 STA + 1 P2P
-        const std::vector<IWifiChip::ChipConcurrencyCombination> combinationsSta =
-		{
-        	{
-				{
-					{{IfaceConcurrencyType::STA}, 1},
-					{{IfaceConcurrencyType::P2P}, 1}
-				}
-			}
-		};
-		// 1 AP
-        const std::vector<IWifiChip::ChipConcurrencyCombination> combinationsAp =
-		{
-            {
-				{
-					{{IfaceConcurrencyType::AP}, 1}
-				}
-			}
+        const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsSta = {
+            {{{{IfaceConcurrencyType::STA}, 1}, {{IfaceConcurrencyType::P2P}, 1}}}
         };
-        const std::vector<IWifiChip::ChipMode> modes = {
+        const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsAp = {
+            {{{{IfaceConcurrencyType::AP}, 1}}}
+        };
+        const std::vector<V1_6::IWifiChip::ChipMode> modes = {
             {feature_flags::chip_mode_ids::kV1Sta, combinationsSta},
             {feature_flags::chip_mode_ids::kV1Ap, combinationsAp}
         };
@@ -73,26 +64,14 @@
 
     void setupV1_AwareIfaceCombination() {
         // clang-format off
-		// 1 STA + 1 of (P2P or NAN)
-        const std::vector<IWifiChip::ChipConcurrencyCombination> combinationsSta =
-		{
-            {
-				{
-					{{IfaceConcurrencyType::STA}, 1},
-              		{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN_IFACE}, 1}
-				}
-			}
+        const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsSta = {
+            {{{{IfaceConcurrencyType::STA}, 1},
+              {{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN}, 1}}}
         };
-		// 1 AP
-        const std::vector<IWifiChip::ChipConcurrencyCombination> combinationsAp =
-		{
-            {
-				{
-					{{IfaceConcurrencyType::AP}, 1}
-				}
-			}
+        const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsAp = {
+            {{{{IfaceConcurrencyType::AP}, 1}}}
         };
-        const std::vector<IWifiChip::ChipMode> modes = {
+        const std::vector<V1_6::IWifiChip::ChipMode> modes = {
             {feature_flags::chip_mode_ids::kV1Sta, combinationsSta},
             {feature_flags::chip_mode_ids::kV1Ap, combinationsAp}
         };
@@ -102,17 +81,11 @@
 
     void setupV1_AwareDisabledApIfaceCombination() {
         // clang-format off
-		// 1 STA + 1 of (P2P or NAN)
-        const std::vector<IWifiChip::ChipConcurrencyCombination> combinationsSta =
-		{
-            {
-				{
-					{{IfaceConcurrencyType::STA}, 1},
-              		{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN_IFACE}, 1}
-				}
-			}
+        const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsSta = {
+            {{{{IfaceConcurrencyType::STA}, 1},
+              {{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN}, 1}}}
         };
-        const std::vector<IWifiChip::ChipMode> modes = {
+        const std::vector<V1_6::IWifiChip::ChipMode> modes = {
             {feature_flags::chip_mode_ids::kV1Sta, combinationsSta}
         };
         // clang-format on
@@ -121,23 +94,12 @@
 
     void setupV2_AwareIfaceCombination() {
         // clang-format off
-		// (1 STA + 1 AP) or (1 STA + 1 of (P2P or NAN))
-        const std::vector<IWifiChip::ChipConcurrencyCombination> combinations =
-		{
-            {
-				{
-					{{IfaceConcurrencyType::STA}, 1},
-					{{IfaceConcurrencyType::AP}, 1}
-				}
-			},
-            {
-				{
-					{{IfaceConcurrencyType::STA}, 1},
-              		{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN_IFACE}, 1}
-				}
-			}
+        const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinations = {
+            {{{{IfaceConcurrencyType::STA}, 1}, {{IfaceConcurrencyType::AP}, 1}}},
+            {{{{IfaceConcurrencyType::STA}, 1},
+              {{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN}, 1}}}
         };
-        const std::vector<IWifiChip::ChipMode> modes = {
+        const std::vector<V1_6::IWifiChip::ChipMode> modes = {
             {feature_flags::chip_mode_ids::kV3, combinations}
         };
         // clang-format on
@@ -146,17 +108,11 @@
 
     void setupV2_AwareDisabledApIfaceCombination() {
         // clang-format off
-		// 1 STA + 1 of (P2P or NAN)
-        const std::vector<IWifiChip::ChipConcurrencyCombination> combinations =
-		{
-            {
-				{
-					{{IfaceConcurrencyType::STA}, 1},
-              		{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN_IFACE}, 1}
-				}
-			}
+        const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinations = {
+            {{{{IfaceConcurrencyType::STA}, 1},
+              {{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN}, 1}}}
         };
-        const std::vector<IWifiChip::ChipMode> modes = {
+        const std::vector<V1_6::IWifiChip::ChipMode> modes = {
             {feature_flags::chip_mode_ids::kV3, combinations}
         };
         // clang-format on
@@ -165,17 +121,10 @@
 
     void setup_MultiIfaceCombination() {
         // clang-format off
-		// 3 STA + 1 AP
-        const std::vector<IWifiChip::ChipConcurrencyCombination> combinations =
-		{
-            {
-				{
-					{{IfaceConcurrencyType::STA}, 3},
-					{{IfaceConcurrencyType::AP}, 1}
-				}
-			}
+        const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinations = {
+            {{{{IfaceConcurrencyType::STA}, 3}, {{IfaceConcurrencyType::AP}, 1}}}
         };
-        const std::vector<IWifiChip::ChipMode> modes = {
+        const std::vector<V1_6::IWifiChip::ChipMode> modes = {
             {feature_flags::chip_mode_ids::kV3, combinations}
         };
         // clang-format on
@@ -183,93 +132,134 @@
     }
 
     void assertNumberOfModes(uint32_t num_modes) {
-        std::vector<IWifiChip::ChipMode> modes;
-        ASSERT_TRUE(chip_->getAvailableModes(&modes).isOk());
-        // V2_Aware has 1 mode of operation.
-        ASSERT_EQ(num_modes, modes.size());
+        chip_->getAvailableModes_1_6([num_modes](const WifiStatus& status,
+                                                 const std::vector<WifiChip::ChipMode>& modes) {
+            ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+            // V2_Aware has 1 mode of operation.
+            ASSERT_EQ(num_modes, modes.size());
+        });
     }
 
     void findModeAndConfigureForIfaceType(const IfaceConcurrencyType& type) {
-        // This should be aligned with kInvalidModeId in wifi_chip.cpp
-        int32_t mode_id = INT32_MAX;
-        std::vector<IWifiChip::ChipMode> modes;
-        ASSERT_TRUE(chip_->getAvailableModes(&modes).isOk());
-
-        for (const auto& mode : modes) {
-            for (const auto& combination : mode.availableCombinations) {
-                for (const auto& limit : combination.limits) {
-                    if (limit.types.end() !=
-                        std::find(limit.types.begin(), limit.types.end(), type)) {
-                        mode_id = mode.id;
+        // This should be aligned with kInvalidModeId in wifi_chip.cpp.
+        ChipModeId mode_id = UINT32_MAX;
+        chip_->getAvailableModes_1_6([&mode_id, &type](
+                                             const WifiStatus& status,
+                                             const std::vector<WifiChip::ChipMode>& modes) {
+            ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+            for (const auto& mode : modes) {
+                for (const auto& combination : mode.availableCombinations) {
+                    for (const auto& limit : combination.limits) {
+                        if (limit.types.end() !=
+                            std::find(limit.types.begin(), limit.types.end(), type)) {
+                            mode_id = mode.id;
+                        }
                     }
                 }
             }
-        }
+        });
+        ASSERT_NE(UINT32_MAX, mode_id);
 
-        ASSERT_NE(INT32_MAX, mode_id);
-        ASSERT_TRUE(chip_->configureChip(mode_id).isOk());
+        chip_->configureChip(mode_id, [](const WifiStatus& status) {
+            ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+        });
     }
 
     // Returns an empty string on error.
     std::string createIface(const IfaceType& type) {
         std::string iface_name;
         if (type == IfaceType::AP) {
-            std::shared_ptr<IWifiApIface> iface;
-            if (!chip_->createApIface(&iface).isOk()) {
-                return "";
-            }
-            EXPECT_NE(iface.get(), nullptr);
-            EXPECT_TRUE(iface->getName(&iface_name).isOk());
-        } else if (type == IfaceType::NAN_IFACE) {
-            std::shared_ptr<IWifiNanIface> iface;
-            if (!chip_->createNanIface(&iface).isOk()) {
-                return "";
-            }
-            EXPECT_NE(iface.get(), nullptr);
-            EXPECT_TRUE(iface->getName(&iface_name).isOk());
+            chip_->createApIface(
+                    [&iface_name](const WifiStatus& status, const sp<V1_0::IWifiApIface>& iface) {
+                        if (WifiStatusCode::SUCCESS == status.code) {
+                            ASSERT_NE(iface.get(), nullptr);
+                            iface->getName([&iface_name](const WifiStatus& status,
+                                                         const hidl_string& name) {
+                                ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+                                iface_name = name.c_str();
+                            });
+                        }
+                    });
+        } else if (type == IfaceType::NAN) {
+            chip_->createNanIface(
+                    [&iface_name](const WifiStatus& status,
+                                  const sp<android::hardware::wifi::V1_0::IWifiNanIface>& iface) {
+                        if (WifiStatusCode::SUCCESS == status.code) {
+                            ASSERT_NE(iface.get(), nullptr);
+                            iface->getName([&iface_name](const WifiStatus& status,
+                                                         const hidl_string& name) {
+                                ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+                                iface_name = name.c_str();
+                            });
+                        }
+                    });
         } else if (type == IfaceType::P2P) {
-            std::shared_ptr<IWifiP2pIface> iface;
-            if (!chip_->createP2pIface(&iface).isOk()) {
-                return "";
-            }
-            EXPECT_NE(iface.get(), nullptr);
-            EXPECT_TRUE(iface->getName(&iface_name).isOk());
+            chip_->createP2pIface(
+                    [&iface_name](const WifiStatus& status, const sp<IWifiP2pIface>& iface) {
+                        if (WifiStatusCode::SUCCESS == status.code) {
+                            ASSERT_NE(iface.get(), nullptr);
+                            iface->getName([&iface_name](const WifiStatus& status,
+                                                         const hidl_string& name) {
+                                ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+                                iface_name = name.c_str();
+                            });
+                        }
+                    });
         } else if (type == IfaceType::STA) {
-            std::shared_ptr<IWifiStaIface> iface;
-            if (!chip_->createStaIface(&iface).isOk()) {
-                return "";
-            }
-            EXPECT_NE(iface.get(), nullptr);
-            EXPECT_TRUE(iface->getName(&iface_name).isOk());
+            chip_->createStaIface(
+                    [&iface_name](const WifiStatus& status, const sp<V1_0::IWifiStaIface>& iface) {
+                        if (WifiStatusCode::SUCCESS == status.code) {
+                            ASSERT_NE(iface.get(), nullptr);
+                            iface->getName([&iface_name](const WifiStatus& status,
+                                                         const hidl_string& name) {
+                                ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+                                iface_name = name.c_str();
+                            });
+                        }
+                    });
         }
         return iface_name;
     }
 
     void removeIface(const IfaceType& type, const std::string& iface_name) {
         if (type == IfaceType::AP) {
-            ASSERT_TRUE(chip_->removeApIface(iface_name).isOk());
-        } else if (type == IfaceType::NAN_IFACE) {
-            ASSERT_TRUE(chip_->removeNanIface(iface_name).isOk());
+            chip_->removeApIface(iface_name, [](const WifiStatus& status) {
+                ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+            });
+        } else if (type == IfaceType::NAN) {
+            chip_->removeNanIface(iface_name, [](const WifiStatus& status) {
+                ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+            });
         } else if (type == IfaceType::P2P) {
-            ASSERT_TRUE(chip_->removeP2pIface(iface_name).isOk());
+            chip_->removeP2pIface(iface_name, [](const WifiStatus& status) {
+                ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+            });
         } else if (type == IfaceType::STA) {
-            ASSERT_TRUE(chip_->removeStaIface(iface_name).isOk());
+            chip_->removeStaIface(iface_name, [](const WifiStatus& status) {
+                ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+            });
         }
     }
 
     bool createRttController() {
-        std::shared_ptr<IWifiRttController> rtt_controller;
-        auto status = chip_->createRttController(nullptr, &rtt_controller);
-        return status.isOk();
+        bool success = false;
+        chip_->createRttController_1_6(
+                NULL, [&success](const WifiStatus& status, const sp<IWifiRttController>& rtt) {
+                    if (WifiStatusCode::SUCCESS == status.code) {
+                        ASSERT_NE(rtt.get(), nullptr);
+                        success = true;
+                    }
+                });
+        return success;
     }
 
     static void subsystemRestartHandler(const std::string& /*error*/) {}
 
-    std::shared_ptr<WifiChip> chip_;
-    int chip_id_ = kFakeChipId;
+    sp<WifiChip> chip_;
+    ChipId chip_id_ = kFakeChipId;
     legacy_hal::wifi_hal_fn fake_func_table_;
-    std::shared_ptr<NiceMock<::android::wifi_system::MockInterfaceTool>> iface_tool_{
-            new NiceMock<::android::wifi_system::MockInterfaceTool>};
+    std::shared_ptr<NiceMock<wifi_system::MockInterfaceTool>> iface_tool_{
+            new NiceMock<wifi_system::MockInterfaceTool>};
     std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
             new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_, fake_func_table_, true)};
     std::shared_ptr<NiceMock<mode_controller::MockWifiModeController>> mode_controller_{
@@ -281,8 +271,8 @@
 
   public:
     void SetUp() override {
-        chip_ = WifiChip::create(chip_id_, true, legacy_hal_, mode_controller_, iface_util_,
-                                 feature_flags_, subsystemRestartHandler);
+        chip_ = new WifiChip(chip_id_, true, legacy_hal_, mode_controller_, iface_util_,
+                             feature_flags_, subsystemRestartHandler);
 
         EXPECT_CALL(*mode_controller_, changeFirmwareMode(testing::_))
                 .WillRepeatedly(testing::Return(true));
@@ -311,7 +301,7 @@
         setupV1IfaceCombination();
         WifiChipTest::SetUp();
         // V1 has 2 modes of operation.
-        assertNumberOfModes(2);
+        assertNumberOfModes(2u);
     }
 };
 
@@ -327,7 +317,7 @@
 
 TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateNan_ShouldFail) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
-    ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_TRUE(createIface(IfaceType::NAN).empty());
 }
 
 TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateAp_ShouldFail) {
@@ -358,7 +348,7 @@
 
 TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateNan_ShouldFail) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
-    ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_TRUE(createIface(IfaceType::NAN).empty());
 }
 
 ////////// V1 + Aware Iface Combinations ////////////
@@ -386,7 +376,7 @@
 
 TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateNan_ShouldSucceed) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
-    ASSERT_FALSE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_FALSE(createIface(IfaceType::NAN).empty());
 }
 
 TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateAp_ShouldFail) {
@@ -403,37 +393,37 @@
 TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaNan_ShouldSucceed) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
     ASSERT_FALSE(createIface(IfaceType::STA).empty());
-    ASSERT_FALSE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_FALSE(createIface(IfaceType::NAN).empty());
 }
 
 TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaP2PNan_ShouldFail) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
     ASSERT_FALSE(createIface(IfaceType::STA).empty());
     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
-    ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_TRUE(createIface(IfaceType::NAN).empty());
 }
 
 TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
     ASSERT_FALSE(createIface(IfaceType::STA).empty());
-    std::string p2p_iface_name = createIface(IfaceType::P2P);
+    const auto p2p_iface_name = createIface(IfaceType::P2P);
     ASSERT_FALSE(p2p_iface_name.empty());
-    ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_TRUE(createIface(IfaceType::NAN).empty());
 
     // After removing P2P iface, NAN iface creation should succeed.
     removeIface(IfaceType::P2P, p2p_iface_name);
-    ASSERT_FALSE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_FALSE(createIface(IfaceType::NAN).empty());
 }
 
 TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
     ASSERT_FALSE(createIface(IfaceType::STA).empty());
-    std::string nan_iface_name = createIface(IfaceType::NAN_IFACE);
+    const auto nan_iface_name = createIface(IfaceType::NAN);
     ASSERT_FALSE(nan_iface_name.empty());
     ASSERT_TRUE(createIface(IfaceType::P2P).empty());
 
     // After removing NAN iface, P2P iface creation should succeed.
-    removeIface(IfaceType::NAN_IFACE, nan_iface_name);
+    removeIface(IfaceType::NAN, nan_iface_name);
     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
 }
 
@@ -454,7 +444,7 @@
 
 TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateNan_ShouldFail) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
-    ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_TRUE(createIface(IfaceType::NAN).empty());
 }
 
 TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowStaModeNoSta) {
@@ -470,7 +460,7 @@
 
 TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowApToSta) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
-    std::string ap_iface_name = createIface(IfaceType::AP);
+    const auto ap_iface_name = createIface(IfaceType::AP);
     ASSERT_FALSE(ap_iface_name.empty());
     ASSERT_FALSE(createRttController());
 
@@ -485,7 +475,9 @@
     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
     EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
             .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
-    ASSERT_TRUE(chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF).isOk());
+    chip_->selectTxPowerScenario_1_2(
+            V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
+            [](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
 }
 
 TEST_F(WifiChipV1_AwareIfaceCombinationTest, SelectTxScenarioWithOnlyAp) {
@@ -493,7 +485,9 @@
     ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
     EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
             .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
-    ASSERT_TRUE(chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF).isOk());
+    chip_->selectTxPowerScenario_1_2(
+            V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
+            [](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
 }
 
 ////////// V2 + Aware Iface Combinations ////////////
@@ -521,7 +515,7 @@
 
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNan_ShouldSucceed) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
-    ASSERT_FALSE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_FALSE(createIface(IfaceType::NAN).empty());
 }
 
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateAp_ShouldSucceed) {
@@ -549,9 +543,9 @@
 
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateSta_AfterStaApRemove_ShouldSucceed) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
-    std::string sta_iface_name = createIface(IfaceType::STA);
+    const auto sta_iface_name = createIface(IfaceType::STA);
     ASSERT_FALSE(sta_iface_name.empty());
-    std::string ap_iface_name = createIface(IfaceType::AP);
+    const auto ap_iface_name = createIface(IfaceType::AP);
     ASSERT_FALSE(ap_iface_name.empty());
 
     ASSERT_TRUE(createIface(IfaceType::STA).empty());
@@ -571,44 +565,44 @@
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaNan_ShouldSucceed) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
     ASSERT_FALSE(createIface(IfaceType::STA).empty());
-    ASSERT_FALSE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_FALSE(createIface(IfaceType::NAN).empty());
 }
 
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaP2PNan_ShouldFail) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
     ASSERT_FALSE(createIface(IfaceType::STA).empty());
     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
-    ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_TRUE(createIface(IfaceType::NAN).empty());
 }
 
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaNan_AfterP2pRemove_ShouldSucceed) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
     ASSERT_FALSE(createIface(IfaceType::STA).empty());
-    std::string p2p_iface_name = createIface(IfaceType::P2P);
+    const auto p2p_iface_name = createIface(IfaceType::P2P);
     ASSERT_FALSE(p2p_iface_name.empty());
-    ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_TRUE(createIface(IfaceType::NAN).empty());
 
     // After removing P2P iface, NAN iface creation should succeed.
     removeIface(IfaceType::P2P, p2p_iface_name);
-    ASSERT_FALSE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_FALSE(createIface(IfaceType::NAN).empty());
 }
 
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaP2p_AfterNanRemove_ShouldSucceed) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
     ASSERT_FALSE(createIface(IfaceType::STA).empty());
-    std::string nan_iface_name = createIface(IfaceType::NAN_IFACE);
+    const auto nan_iface_name = createIface(IfaceType::NAN);
     ASSERT_FALSE(nan_iface_name.empty());
     ASSERT_TRUE(createIface(IfaceType::P2P).empty());
 
     // After removing NAN iface, P2P iface creation should succeed.
-    removeIface(IfaceType::NAN_IFACE, nan_iface_name);
+    removeIface(IfaceType::NAN, nan_iface_name);
     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
 }
 
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApNan_ShouldFail) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
     ASSERT_FALSE(createIface(IfaceType::AP).empty());
-    ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_TRUE(createIface(IfaceType::NAN).empty());
 }
 
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApP2p_ShouldFail) {
@@ -620,31 +614,31 @@
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
     ASSERT_FALSE(createIface(IfaceType::STA).empty());
-    std::string p2p_iface_name = createIface(IfaceType::P2P);
+    const auto p2p_iface_name = createIface(IfaceType::P2P);
     ASSERT_FALSE(p2p_iface_name.empty());
-    ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_TRUE(createIface(IfaceType::NAN).empty());
 
     // After removing P2P iface, NAN iface creation should succeed.
     removeIface(IfaceType::P2P, p2p_iface_name);
-    ASSERT_FALSE(createIface(IfaceType::NAN_IFACE).empty());
+    ASSERT_FALSE(createIface(IfaceType::NAN).empty());
 }
 
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
     ASSERT_FALSE(createIface(IfaceType::STA).empty());
-    std::string nan_iface_name = createIface(IfaceType::NAN_IFACE);
+    const auto nan_iface_name = createIface(IfaceType::NAN);
     ASSERT_FALSE(nan_iface_name.empty());
     ASSERT_TRUE(createIface(IfaceType::P2P).empty());
 
     // After removing NAN iface, P2P iface creation should succeed.
-    removeIface(IfaceType::NAN_IFACE, nan_iface_name);
+    removeIface(IfaceType::NAN, nan_iface_name);
     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
 }
 
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaAp_EnsureDifferentIfaceNames) {
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
-    std::string sta_iface_name = createIface(IfaceType::STA);
-    std::string ap_iface_name = createIface(IfaceType::AP);
+    const auto sta_iface_name = createIface(IfaceType::STA);
+    const auto ap_iface_name = createIface(IfaceType::AP);
     ASSERT_FALSE(sta_iface_name.empty());
     ASSERT_FALSE(ap_iface_name.empty());
     ASSERT_NE(sta_iface_name, ap_iface_name);
@@ -673,7 +667,9 @@
     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
     EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
             .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
-    ASSERT_TRUE(chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF).isOk());
+    chip_->selectTxPowerScenario_1_2(
+            V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
+            [](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
 }
 
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, SelectTxScenarioWithOnlyAp) {
@@ -681,7 +677,9 @@
     ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
     EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan1", testing::_))
             .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
-    ASSERT_TRUE(chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF).isOk());
+    chip_->selectTxPowerScenario_1_2(
+            V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
+            [](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
 }
 
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, InvalidateAndRemoveNanOnStaRemove) {
@@ -689,29 +687,35 @@
     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
 
     // Create NAN iface
-    ASSERT_EQ(createIface(IfaceType::NAN_IFACE), "wlan0");
+    ASSERT_EQ(createIface(IfaceType::NAN), "wlan0");
 
     // We should have 1 nan iface.
-    std::vector<std::string> iface_names;
-    ASSERT_TRUE(chip_->getNanIfaceNames(&iface_names).isOk());
-    ASSERT_EQ(iface_names.size(), 1u);
-    ASSERT_EQ(iface_names[0], "wlan0");
+    chip_->getNanIfaceNames([](const WifiStatus& status, const hidl_vec<hidl_string>& iface_names) {
+        ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+        ASSERT_EQ(iface_names.size(), 1u);
+        ASSERT_EQ(iface_names[0], "wlan0");
+    });
+    // Retrieve the exact iface object.
+    sp<android::hardware::wifi::V1_0::IWifiNanIface> nan_iface;
+    chip_->getNanIface("wlan0",
+                       [&nan_iface](const WifiStatus& status,
+                                    const sp<android::hardware::wifi::V1_0::IWifiNanIface>& iface) {
+                           ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+                           ASSERT_NE(iface.get(), nullptr);
+                           nan_iface = iface;
+                       });
 
-    // Retrieve the nan iface object.
-    std::shared_ptr<IWifiNanIface> nan_iface;
-    ASSERT_TRUE(chip_->getNanIface("wlan0", &nan_iface).isOk());
-    ASSERT_NE(nan_iface.get(), nullptr);
-
-    // Remove the STA iface. We should have 0 nan ifaces now.
+    // Remove the STA iface.
     removeIface(IfaceType::STA, "wlan0");
-    ASSERT_TRUE(chip_->getNanIfaceNames(&iface_names).isOk());
-    ASSERT_EQ(iface_names.size(), 0u);
-
-    // Any operation on the nan iface object should now return an error.
-    std::string name;
-    auto status = nan_iface->getName(&name);
-    ASSERT_EQ(status.getServiceSpecificError(),
-              static_cast<int32_t>(WifiStatusCode::ERROR_WIFI_IFACE_INVALID));
+    // We should have 0 nan iface now.
+    chip_->getNanIfaceNames([](const WifiStatus& status, const hidl_vec<hidl_string>& iface_names) {
+        ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+        ASSERT_EQ(iface_names.size(), 0u);
+    });
+    // Any operation on the nan iface object should return error now.
+    nan_iface->getName([](const WifiStatus& status, const std::string& /* iface_name */) {
+        ASSERT_EQ(WifiStatusCode::ERROR_WIFI_IFACE_INVALID, status.code);
+    });
 }
 
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, InvalidateAndRemoveRttControllerOnStaRemove) {
@@ -719,25 +723,30 @@
     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
 
     // Create RTT controller
-    std::shared_ptr<IWifiRttController> rtt_controller;
-    ASSERT_TRUE(chip_->createRttController(nullptr, &rtt_controller).isOk());
+    sp<IWifiRttController> rtt_controller;
+    chip_->createRttController_1_6(
+            NULL, [&rtt_controller](const WifiStatus& status, const sp<IWifiRttController>& rtt) {
+                if (WifiStatusCode::SUCCESS == status.code) {
+                    ASSERT_NE(rtt.get(), nullptr);
+                    rtt_controller = rtt;
+                }
+            });
 
     // Remove the STA iface.
     removeIface(IfaceType::STA, "wlan0");
 
-    // Any operation on the rtt controller object should now return an error.
-    std::shared_ptr<IWifiStaIface> bound_iface;
-    auto status = rtt_controller->getBoundIface(&bound_iface);
-    ASSERT_EQ(status.getServiceSpecificError(),
-              static_cast<int32_t>(WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID));
+    // Any operation on the rtt controller object should return error now.
+    rtt_controller->getBoundIface([](const WifiStatus& status, const sp<IWifiIface>& /* iface */) {
+        ASSERT_EQ(WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID, status.code);
+    });
 }
 
 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNanWithSharedNanIface) {
     property_set("wifi.aware.interface", nullptr);
     findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
-    ASSERT_EQ(createIface(IfaceType::NAN_IFACE), "wlan0");
-    removeIface(IfaceType::NAN_IFACE, "wlan0");
+    ASSERT_EQ(createIface(IfaceType::NAN), "wlan0");
+    removeIface(IfaceType::NAN, "wlan0");
     EXPECT_CALL(*iface_util_, setUpState(testing::_, testing::_)).Times(0);
 }
 
@@ -747,10 +756,10 @@
     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
     EXPECT_CALL(*iface_util_, ifNameToIndex("aware0")).WillOnce(testing::Return(4));
     EXPECT_CALL(*iface_util_, setUpState("aware0", true)).WillOnce(testing::Return(true));
-    ASSERT_EQ(createIface(IfaceType::NAN_IFACE), "aware0");
+    ASSERT_EQ(createIface(IfaceType::NAN), "aware0");
 
     EXPECT_CALL(*iface_util_, setUpState("aware0", false)).WillOnce(testing::Return(true));
-    removeIface(IfaceType::NAN_IFACE, "aware0");
+    removeIface(IfaceType::NAN, "aware0");
 }
 
 ////////// V1 Iface Combinations when AP creation is disabled //////////
@@ -848,8 +857,8 @@
     ASSERT_EQ(createIface(IfaceType::STA), "wlan1");
     ASSERT_EQ(createIface(IfaceType::STA), "wlan3");
 }
-
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/tests/wifi_iface_util_unit_tests.cpp b/wifi/1.6/default/tests/wifi_iface_util_unit_tests.cpp
similarity index 91%
rename from wifi/aidl/default/tests/wifi_iface_util_unit_tests.cpp
rename to wifi/1.6/default/tests/wifi_iface_util_unit_tests.cpp
index e0db6fd..cc9a334 100644
--- a/wifi/aidl/default/tests/wifi_iface_util_unit_tests.cpp
+++ b/wifi/1.6/default/tests/wifi_iface_util_unit_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2019, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,6 +18,7 @@
 #include <android-base/macros.h>
 #include <gmock/gmock.h>
 
+#undef NAN
 #include "wifi_iface_util.h"
 
 #include "mock_interface_tool.h"
@@ -37,16 +38,16 @@
 }
 }  // namespace
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace iface_util {
-
 class WifiIfaceUtilTest : public Test {
   protected:
-    std::shared_ptr<NiceMock<::android::wifi_system::MockInterfaceTool>> iface_tool_{
-            new NiceMock<::android::wifi_system::MockInterfaceTool>};
+    std::shared_ptr<NiceMock<wifi_system::MockInterfaceTool>> iface_tool_{
+            new NiceMock<wifi_system::MockInterfaceTool>};
     legacy_hal::wifi_hal_fn fake_func_table_;
     std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
             new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_, fake_func_table_, true)};
@@ -88,7 +89,8 @@
     ASSERT_FALSE(callback_invoked);
 }
 }  // namespace iface_util
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/1.6/default/tests/wifi_nan_iface_unit_tests.cpp b/wifi/1.6/default/tests/wifi_nan_iface_unit_tests.cpp
new file mode 100644
index 0000000..8a5ddcd
--- /dev/null
+++ b/wifi/1.6/default/tests/wifi_nan_iface_unit_tests.cpp
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2019, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <android-base/logging.h>
+#include <android-base/macros.h>
+#include <cutils/properties.h>
+#include <gmock/gmock.h>
+
+#undef NAN  // This is weird, NAN is defined in bionic/libc/include/math.h:38
+#include "wifi_nan_iface.h"
+
+#include "mock_interface_tool.h"
+#include "mock_wifi_feature_flags.h"
+#include "mock_wifi_iface_util.h"
+#include "mock_wifi_legacy_hal.h"
+
+using testing::NiceMock;
+using testing::Return;
+using testing::Test;
+
+namespace {
+constexpr char kIfaceName[] = "mockWlan0";
+}  // namespace
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+
+using android::hardware::wifi::V1_2::NanDataPathConfirmInd;
+
+bool CaptureIfaceEventHandlers(const std::string& /* iface_name*/,
+                               iface_util::IfaceEventHandlers in_iface_event_handlers,
+                               iface_util::IfaceEventHandlers* out_iface_event_handlers) {
+    *out_iface_event_handlers = in_iface_event_handlers;
+    return true;
+}
+
+class MockNanIfaceEventCallback : public V1_5::IWifiNanIfaceEventCallback {
+  public:
+    MockNanIfaceEventCallback() = default;
+
+    MOCK_METHOD3(notifyCapabilitiesResponse,
+                 Return<void>(uint16_t, const WifiNanStatus&,
+                              const android::hardware::wifi::V1_0::NanCapabilities&));
+    MOCK_METHOD2(notifyEnableResponse, Return<void>(uint16_t, const WifiNanStatus&));
+    MOCK_METHOD2(notifyConfigResponse, Return<void>(uint16_t, const WifiNanStatus&));
+    MOCK_METHOD2(notifyDisableResponse, Return<void>(uint16_t, const WifiNanStatus&));
+    MOCK_METHOD3(notifyStartPublishResponse, Return<void>(uint16_t, const WifiNanStatus&, uint8_t));
+    MOCK_METHOD2(notifyStopPublishResponse, Return<void>(uint16_t, const WifiNanStatus&));
+    MOCK_METHOD3(notifyStartSubscribeResponse,
+                 Return<void>(uint16_t, const WifiNanStatus&, uint8_t));
+    MOCK_METHOD2(notifyStopSubscribeResponse, Return<void>(uint16_t, const WifiNanStatus&));
+    MOCK_METHOD2(notifyTransmitFollowupResponse, Return<void>(uint16_t, const WifiNanStatus&));
+    MOCK_METHOD2(notifyCreateDataInterfaceResponse, Return<void>(uint16_t, const WifiNanStatus&));
+    MOCK_METHOD2(notifyDeleteDataInterfaceResponse, Return<void>(uint16_t, const WifiNanStatus&));
+    MOCK_METHOD3(notifyInitiateDataPathResponse,
+                 Return<void>(uint16_t, const WifiNanStatus&, uint32_t));
+    MOCK_METHOD2(notifyRespondToDataPathIndicationResponse,
+                 Return<void>(uint16_t, const WifiNanStatus&));
+    MOCK_METHOD2(notifyTerminateDataPathResponse, Return<void>(uint16_t, const WifiNanStatus&));
+    MOCK_METHOD1(eventClusterEvent, Return<void>(const NanClusterEventInd&));
+    MOCK_METHOD1(eventDisabled, Return<void>(const WifiNanStatus&));
+    MOCK_METHOD2(eventPublishTerminated, Return<void>(uint8_t, const WifiNanStatus&));
+    MOCK_METHOD2(eventSubscribeTerminated, Return<void>(uint8_t, const WifiNanStatus&));
+    MOCK_METHOD1(eventMatch, Return<void>(const V1_0::NanMatchInd&));
+    MOCK_METHOD1(eventMatch_1_6, Return<void>(const NanMatchInd&));
+    MOCK_METHOD2(eventMatchExpired, Return<void>(uint8_t, uint32_t));
+    MOCK_METHOD1(eventFollowupReceived, Return<void>(const NanFollowupReceivedInd&));
+    MOCK_METHOD2(eventTransmitFollowup, Return<void>(uint16_t, const WifiNanStatus&));
+    MOCK_METHOD1(eventDataPathRequest, Return<void>(const NanDataPathRequestInd&));
+    MOCK_METHOD1(eventDataPathConfirm,
+                 Return<void>(const android::hardware::wifi::V1_0::NanDataPathConfirmInd&));
+    MOCK_METHOD1(eventDataPathTerminated, Return<void>(uint32_t));
+    MOCK_METHOD1(eventDataPathConfirm_1_2,
+                 Return<void>(const android::hardware::wifi::V1_2::NanDataPathConfirmInd&));
+    MOCK_METHOD1(eventDataPathConfirm_1_6, Return<void>(const NanDataPathConfirmInd&));
+    MOCK_METHOD1(eventDataPathScheduleUpdate,
+                 Return<void>(const android::hardware::wifi::V1_2::NanDataPathScheduleUpdateInd&));
+    MOCK_METHOD1(eventDataPathScheduleUpdate_1_6,
+                 Return<void>(const NanDataPathScheduleUpdateInd&));
+    MOCK_METHOD3(notifyCapabilitiesResponse_1_5,
+                 Return<void>(uint16_t, const WifiNanStatus&, const V1_5::NanCapabilities&));
+};
+
+class WifiNanIfaceTest : public Test {
+  protected:
+    legacy_hal::wifi_hal_fn fake_func_table_;
+    std::shared_ptr<NiceMock<wifi_system::MockInterfaceTool>> iface_tool_{
+            new NiceMock<wifi_system::MockInterfaceTool>};
+    std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
+            new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_, fake_func_table_, true)};
+    std::shared_ptr<NiceMock<iface_util::MockWifiIfaceUtil>> iface_util_{
+            new NiceMock<iface_util::MockWifiIfaceUtil>(iface_tool_, legacy_hal_)};
+};
+
+TEST_F(WifiNanIfaceTest, IfacEventHandlers_OnStateToggleOffOn) {
+    iface_util::IfaceEventHandlers captured_iface_event_handlers = {};
+    EXPECT_CALL(*legacy_hal_, nanRegisterCallbackHandlers(testing::_, testing::_))
+            .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
+    EXPECT_CALL(*iface_util_, registerIfaceEventHandlers(testing::_, testing::_))
+            .WillOnce(testing::Invoke(bind(CaptureIfaceEventHandlers, std::placeholders::_1,
+                                           std::placeholders::_2, &captured_iface_event_handlers)));
+    sp<WifiNanIface> nan_iface = new WifiNanIface(kIfaceName, false, legacy_hal_, iface_util_);
+
+    // Register a mock nan event callback.
+    sp<NiceMock<MockNanIfaceEventCallback>> mock_event_callback{
+            new NiceMock<MockNanIfaceEventCallback>};
+    nan_iface->registerEventCallback(mock_event_callback, [](const WifiStatus& status) {
+        ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
+    });
+    // Ensure that the eventDisabled() function in mock callback will be
+    // invoked.
+    WifiNanStatus expected_nan_status = {NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED, ""};
+    EXPECT_CALL(*mock_event_callback, eventDisabled(expected_nan_status)).Times(1);
+
+    // Trigger the iface state toggle callback.
+    captured_iface_event_handlers.on_state_toggle_off_on(kIfaceName);
+}
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
diff --git a/wifi/aidl/default/wifi.cpp b/wifi/1.6/default/wifi.cpp
similarity index 60%
rename from wifi/aidl/default/wifi.cpp
rename to wifi/1.6/default/wifi.cpp
index e30c38a..c302ce2 100644
--- a/wifi/aidl/default/wifi.cpp
+++ b/wifi/1.6/default/wifi.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include "wifi.h"
-
 #include <android-base/logging.h>
 
-#include "aidl_return_util.h"
+#include "hidl_return_util.h"
+#include "wifi.h"
 #include "wifi_status_util.h"
 
 namespace {
 // Starting Chip ID, will be assigned to primary chip
-static constexpr int32_t kPrimaryChipId = 0;
+static constexpr android::hardware::wifi::V1_0::ChipId kPrimaryChipId = 0;
 }  // namespace
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
-using aidl_return_util::validateAndCall;
-using aidl_return_util::validateAndCallWithLock;
+namespace V1_6 {
+namespace implementation {
+using hidl_return_util::validateAndCall;
+using hidl_return_util::validateAndCallWithLock;
 
-Wifi::Wifi(const std::shared_ptr<::android::wifi_system::InterfaceTool> iface_tool,
+Wifi::Wifi(const std::shared_ptr<wifi_system::InterfaceTool> iface_tool,
            const std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory,
            const std::shared_ptr<mode_controller::WifiModeController> mode_controller,
            const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags)
@@ -48,74 +48,86 @@
     return true;
 }
 
-ndk::ScopedAStatus Wifi::registerEventCallback(
-        const std::shared_ptr<IWifiEventCallback>& in_callback) {
+Return<void> Wifi::registerEventCallback(const sp<V1_0::IWifiEventCallback>& event_callback,
+                                         registerEventCallback_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
-                           &Wifi::registerEventCallbackInternal, in_callback);
+                           &Wifi::registerEventCallbackInternal, hidl_status_cb, event_callback);
 }
 
-ndk::ScopedAStatus Wifi::isStarted(bool* _aidl_return) {
-    *_aidl_return = (run_state_ != RunState::STOPPED);
-    return ndk::ScopedAStatus::ok();
+Return<void> Wifi::registerEventCallback_1_5(const sp<V1_5::IWifiEventCallback>& event_callback,
+                                             registerEventCallback_1_5_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
+                           &Wifi::registerEventCallbackInternal_1_5, hidl_status_cb,
+                           event_callback);
 }
 
-ndk::ScopedAStatus Wifi::start() {
-    return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::startInternal);
+Return<bool> Wifi::isStarted() {
+    return run_state_ != RunState::STOPPED;
 }
 
-ndk::ScopedAStatus Wifi::stop() {
-    return validateAndCallWithLock(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::stopInternal);
+Return<void> Wifi::start(start_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::startInternal,
+                           hidl_status_cb);
 }
 
-ndk::ScopedAStatus Wifi::getChipIds(std::vector<int32_t>* _aidl_return) {
+Return<void> Wifi::stop(stop_cb hidl_status_cb) {
+    return validateAndCallWithLock(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::stopInternal,
+                                   hidl_status_cb);
+}
+
+Return<void> Wifi::getChipIds(getChipIds_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::getChipIdsInternal,
-                           _aidl_return);
+                           hidl_status_cb);
 }
 
-ndk::ScopedAStatus Wifi::getChip(int32_t in_chipId, std::shared_ptr<IWifiChip>* _aidl_return) {
+Return<void> Wifi::getChip(ChipId chip_id, getChip_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::getChipInternal,
-                           _aidl_return, in_chipId);
+                           hidl_status_cb, chip_id);
 }
 
-binder_status_t Wifi::dump(int fd, const char** args, uint32_t numArgs) {
-    LOG(INFO) << "-----------Debug was called----------------";
+Return<void> Wifi::debug(const hidl_handle& handle, const hidl_vec<hidl_string>&) {
+    LOG(INFO) << "-----------Debug is called----------------";
     if (chips_.size() == 0) {
-        LOG(INFO) << "No chips to display.";
-        return STATUS_OK;
+        return Void();
     }
 
-    for (std::shared_ptr<WifiChip> chip : chips_) {
+    for (sp<WifiChip> chip : chips_) {
         if (!chip.get()) continue;
-        chip->dump(fd, args, numArgs);
+
+        chip->debug(handle, {});
     }
-    return STATUS_OK;
+    return Void();
 }
 
-ndk::ScopedAStatus Wifi::registerEventCallbackInternal(
-        const std::shared_ptr<IWifiEventCallback>& event_callback) {
+WifiStatus Wifi::registerEventCallbackInternal(
+        const sp<V1_0::IWifiEventCallback>& event_callback __unused) {
+    // Deprecated support for this callback.
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus Wifi::registerEventCallbackInternal_1_5(
+        const sp<V1_5::IWifiEventCallback>& event_callback) {
     if (!event_cb_handler_.addCallback(event_callback)) {
         return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
     }
-    return ndk::ScopedAStatus::ok();
+    return createWifiStatus(WifiStatusCode::SUCCESS);
 }
 
-ndk::ScopedAStatus Wifi::startInternal() {
+WifiStatus Wifi::startInternal() {
     if (run_state_ == RunState::STARTED) {
-        return ndk::ScopedAStatus::ok();
+        return createWifiStatus(WifiStatusCode::SUCCESS);
     } else if (run_state_ == RunState::STOPPING) {
         return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE, "HAL is stopping");
     }
-    ndk::ScopedAStatus wifi_status = initializeModeControllerAndLegacyHal();
-    if (wifi_status.isOk()) {
+    WifiStatus wifi_status = initializeModeControllerAndLegacyHal();
+    if (wifi_status.code == WifiStatusCode::SUCCESS) {
         // Register the callback for subsystem restart
         const auto& on_subsystem_restart_callback = [this](const std::string& error) {
-            ndk::ScopedAStatus wifi_status = createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, error);
+            WifiStatus wifi_status = createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, error);
             for (const auto& callback : event_cb_handler_.getCallbacks()) {
                 LOG(INFO) << "Attempting to invoke onSubsystemRestart "
                              "callback";
-                WifiStatusCode errorCode =
-                        static_cast<WifiStatusCode>(wifi_status.getServiceSpecificError());
-                if (!callback->onSubsystemRestart(errorCode).isOk()) {
+                if (!callback->onSubsystemRestart(wifi_status).isOk()) {
                     LOG(ERROR) << "Failed to invoke onSubsystemRestart callback";
                 } else {
                     LOG(INFO) << "Succeeded to invoke onSubsystemRestart "
@@ -125,12 +137,12 @@
         };
 
         // Create the chip instance once the HAL is started.
-        int32_t chipId = kPrimaryChipId;
+        android::hardware::wifi::V1_0::ChipId chipId = kPrimaryChipId;
         for (auto& hal : legacy_hals_) {
             chips_.push_back(
-                    WifiChip::create(chipId, chipId == kPrimaryChipId, hal, mode_controller_,
-                                     std::make_shared<iface_util::WifiIfaceUtil>(iface_tool_, hal),
-                                     feature_flags_, on_subsystem_restart_callback));
+                    new WifiChip(chipId, chipId == kPrimaryChipId, hal, mode_controller_,
+                                 std::make_shared<iface_util::WifiIfaceUtil>(iface_tool_, hal),
+                                 feature_flags_, on_subsystem_restart_callback));
             chipId++;
         }
         run_state_ = RunState::STARTED;
@@ -142,9 +154,7 @@
         LOG(INFO) << "Wifi HAL started";
     } else {
         for (const auto& callback : event_cb_handler_.getCallbacks()) {
-            WifiStatusCode errorCode =
-                    static_cast<WifiStatusCode>(wifi_status.getServiceSpecificError());
-            if (!callback->onFailure(errorCode).isOk()) {
+            if (!callback->onFailure(wifi_status).isOk()) {
                 LOG(ERROR) << "Failed to invoke onFailure callback";
             }
         }
@@ -155,10 +165,10 @@
     return wifi_status;
 }
 
-ndk::ScopedAStatus Wifi::stopInternal(
+WifiStatus Wifi::stopInternal(
         /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
     if (run_state_ == RunState::STOPPED) {
-        return ndk::ScopedAStatus::ok();
+        return createWifiStatus(WifiStatusCode::SUCCESS);
     } else if (run_state_ == RunState::STOPPING) {
         return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE, "HAL is stopping");
     }
@@ -167,12 +177,12 @@
     for (auto& chip : chips_) {
         if (chip.get()) {
             chip->invalidate();
-            chip.reset();
+            chip.clear();
         }
     }
     chips_.clear();
-    ndk::ScopedAStatus wifi_status = stopLegacyHalAndDeinitializeModeController(lock);
-    if (wifi_status.isOk()) {
+    WifiStatus wifi_status = stopLegacyHalAndDeinitializeModeController(lock);
+    if (wifi_status.code == WifiStatusCode::SUCCESS) {
         for (const auto& callback : event_cb_handler_.getCallbacks()) {
             if (!callback->onStop().isOk()) {
                 LOG(ERROR) << "Failed to invoke onStop callback";
@@ -181,9 +191,7 @@
         LOG(INFO) << "Wifi HAL stopped";
     } else {
         for (const auto& callback : event_cb_handler_.getCallbacks()) {
-            WifiStatusCode errorCode =
-                    static_cast<WifiStatusCode>(wifi_status.getServiceSpecificError());
-            if (!callback->onFailure(errorCode).isOk()) {
+            if (!callback->onFailure(wifi_status).isOk()) {
                 LOG(ERROR) << "Failed to invoke onFailure callback";
             }
         }
@@ -194,26 +202,27 @@
     return wifi_status;
 }
 
-std::pair<std::vector<int32_t>, ndk::ScopedAStatus> Wifi::getChipIdsInternal() {
-    std::vector<int32_t> chip_ids;
+std::pair<WifiStatus, std::vector<ChipId>> Wifi::getChipIdsInternal() {
+    std::vector<ChipId> chip_ids;
 
     for (auto& chip : chips_) {
-        int32_t chip_id = getChipIdFromWifiChip(chip);
-        if (chip_id != INT32_MAX) chip_ids.emplace_back(chip_id);
+        ChipId chip_id = getChipIdFromWifiChip(chip);
+        if (chip_id != UINT32_MAX) chip_ids.emplace_back(chip_id);
     }
-    return {std::move(chip_ids), ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), std::move(chip_ids)};
 }
 
-std::pair<std::shared_ptr<IWifiChip>, ndk::ScopedAStatus> Wifi::getChipInternal(int32_t chip_id) {
+std::pair<WifiStatus, sp<V1_4::IWifiChip>> Wifi::getChipInternal(ChipId chip_id) {
     for (auto& chip : chips_) {
-        int32_t cand_id = getChipIdFromWifiChip(chip);
-        if ((cand_id != INT32_MAX) && (cand_id == chip_id)) return {chip, ndk::ScopedAStatus::ok()};
+        ChipId cand_id = getChipIdFromWifiChip(chip);
+        if ((cand_id != UINT32_MAX) && (cand_id == chip_id))
+            return {createWifiStatus(WifiStatusCode::SUCCESS), chip};
     }
 
-    return {nullptr, createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS)};
+    return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
 }
 
-ndk::ScopedAStatus Wifi::initializeModeControllerAndLegacyHal() {
+WifiStatus Wifi::initializeModeControllerAndLegacyHal() {
     if (!mode_controller_->initialize()) {
         LOG(ERROR) << "Failed to initialize firmware mode controller";
         return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
@@ -235,10 +244,10 @@
         }
         index++;
     }
-    return ndk::ScopedAStatus::ok();
+    return createWifiStatus(WifiStatusCode::SUCCESS);
 }
 
-ndk::ScopedAStatus Wifi::stopLegacyHalAndDeinitializeModeController(
+WifiStatus Wifi::stopLegacyHalAndDeinitializeModeController(
         /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
     legacy_hal::wifi_error legacy_status = legacy_hal::WIFI_SUCCESS;
     int index = 0;
@@ -263,22 +272,23 @@
         LOG(ERROR) << "Failed to deinitialize firmware mode controller";
         return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
     }
-    return ndk::ScopedAStatus::ok();
+    return createWifiStatus(WifiStatusCode::SUCCESS);
 }
 
-int32_t Wifi::getChipIdFromWifiChip(std::shared_ptr<WifiChip>& chip) {
-    int32_t chip_id = INT32_MAX;
+ChipId Wifi::getChipIdFromWifiChip(sp<WifiChip>& chip) {
+    ChipId chip_id = UINT32_MAX;
     if (chip.get()) {
-        ndk::ScopedAStatus status = chip->getId(&chip_id);
-        if (!status.isOk()) {
-            // Reset value if operation failed.
-            chip_id = INT32_MAX;
-        }
+        chip->getId([&](WifiStatus status, uint32_t id) {
+            if (status.code == WifiStatusCode::SUCCESS) {
+                chip_id = id;
+            }
+        });
     }
+
     return chip_id;
 }
-
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/1.6/default/wifi.h b/wifi/1.6/default/wifi.h
new file mode 100644
index 0000000..435358e
--- /dev/null
+++ b/wifi/1.6/default/wifi.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WIFI_H_
+#define WIFI_H_
+
+// HACK: NAN is a macro defined in math.h, which can be included in various
+// headers. This wifi HAL uses an enum called NAN, which does not compile when
+// the macro is defined. Undefine NAN to work around it.
+#undef NAN
+#include <android/hardware/wifi/1.6/IWifi.h>
+
+#include <android-base/macros.h>
+#include <utils/Looper.h>
+#include <functional>
+
+#include "hidl_callback_util.h"
+#include "wifi_chip.h"
+#include "wifi_feature_flags.h"
+#include "wifi_legacy_hal.h"
+#include "wifi_legacy_hal_factory.h"
+#include "wifi_mode_controller.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+
+/**
+ * Root HIDL interface object used to control the Wifi HAL.
+ */
+class Wifi : public V1_6::IWifi {
+  public:
+    Wifi(const std::shared_ptr<wifi_system::InterfaceTool> iface_tool,
+         const std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory,
+         const std::shared_ptr<mode_controller::WifiModeController> mode_controller,
+         const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags);
+
+    bool isValid();
+
+    // HIDL methods exposed.
+    Return<void> registerEventCallback(const sp<V1_0::IWifiEventCallback>& event_callback,
+                                       registerEventCallback_cb hidl_status_cb) override;
+    Return<void> registerEventCallback_1_5(const sp<V1_5::IWifiEventCallback>& event_callback,
+                                           registerEventCallback_1_5_cb hidl_status_cb) override;
+    Return<bool> isStarted() override;
+    Return<void> start(start_cb hidl_status_cb) override;
+    Return<void> stop(stop_cb hidl_status_cb) override;
+    Return<void> getChipIds(getChipIds_cb hidl_status_cb) override;
+    Return<void> getChip(ChipId chip_id, getChip_cb hidl_status_cb) override;
+    Return<void> debug(const hidl_handle& handle, const hidl_vec<hidl_string>& options) override;
+
+  private:
+    enum class RunState { STOPPED, STARTED, STOPPING };
+
+    // Corresponding worker functions for the HIDL methods.
+    WifiStatus registerEventCallbackInternal(
+            const sp<V1_0::IWifiEventCallback>& event_callback __unused);
+    WifiStatus registerEventCallbackInternal_1_5(
+            const sp<V1_5::IWifiEventCallback>& event_callback);
+    WifiStatus startInternal();
+    WifiStatus stopInternal(std::unique_lock<std::recursive_mutex>* lock);
+    std::pair<WifiStatus, std::vector<ChipId>> getChipIdsInternal();
+    std::pair<WifiStatus, sp<V1_4::IWifiChip>> getChipInternal(ChipId chip_id);
+
+    WifiStatus initializeModeControllerAndLegacyHal();
+    WifiStatus stopLegacyHalAndDeinitializeModeController(
+            std::unique_lock<std::recursive_mutex>* lock);
+    ChipId getChipIdFromWifiChip(sp<WifiChip>& chip);
+
+    // Instance is created in this root level |IWifi| HIDL interface object
+    // and shared with all the child HIDL interface objects.
+    std::shared_ptr<wifi_system::InterfaceTool> iface_tool_;
+    std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory_;
+    std::shared_ptr<mode_controller::WifiModeController> mode_controller_;
+    std::vector<std::shared_ptr<legacy_hal::WifiLegacyHal>> legacy_hals_;
+    std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags_;
+    RunState run_state_;
+    std::vector<sp<WifiChip>> chips_;
+    hidl_callback_util::HidlCallbackHandler<V1_5::IWifiEventCallback> event_cb_handler_;
+
+    DISALLOW_COPY_AND_ASSIGN(Wifi);
+};
+
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
+
+#endif  // WIFI_H_
diff --git a/wifi/1.6/default/wifi_ap_iface.cpp b/wifi/1.6/default/wifi_ap_iface.cpp
new file mode 100644
index 0000000..b2957db
--- /dev/null
+++ b/wifi/1.6/default/wifi_ap_iface.cpp
@@ -0,0 +1,204 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <android-base/logging.h>
+
+#include "hidl_return_util.h"
+#include "hidl_struct_util.h"
+#include "wifi_ap_iface.h"
+#include "wifi_status_util.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+using hidl_return_util::validateAndCall;
+
+WifiApIface::WifiApIface(const std::string& ifname, const std::vector<std::string>& instances,
+                         const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
+                         const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
+    : ifname_(ifname),
+      instances_(instances),
+      legacy_hal_(legacy_hal),
+      iface_util_(iface_util),
+      is_valid_(true) {}
+
+void WifiApIface::invalidate() {
+    legacy_hal_.reset();
+    is_valid_ = false;
+}
+
+bool WifiApIface::isValid() {
+    return is_valid_;
+}
+
+std::string WifiApIface::getName() {
+    return ifname_;
+}
+
+void WifiApIface::removeInstance(std::string instance) {
+    instances_.erase(std::remove(instances_.begin(), instances_.end(), instance), instances_.end());
+}
+
+Return<void> WifiApIface::getName(getName_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiApIface::getNameInternal, hidl_status_cb);
+}
+
+Return<void> WifiApIface::getType(getType_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiApIface::getTypeInternal, hidl_status_cb);
+}
+
+Return<void> WifiApIface::setCountryCode(const hidl_array<int8_t, 2>& code,
+                                         setCountryCode_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiApIface::setCountryCodeInternal, hidl_status_cb, code);
+}
+
+Return<void> WifiApIface::getValidFrequenciesForBand(V1_0::WifiBand band,
+                                                     getValidFrequenciesForBand_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiApIface::getValidFrequenciesForBandInternal, hidl_status_cb, band);
+}
+
+Return<void> WifiApIface::setMacAddress(const hidl_array<uint8_t, 6>& mac,
+                                        setMacAddress_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiApIface::setMacAddressInternal, hidl_status_cb, mac);
+}
+
+Return<void> WifiApIface::getFactoryMacAddress(getFactoryMacAddress_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiApIface::getFactoryMacAddressInternal, hidl_status_cb,
+                           instances_.size() > 0 ? instances_[0] : ifname_);
+}
+
+Return<void> WifiApIface::resetToFactoryMacAddress(resetToFactoryMacAddress_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiApIface::resetToFactoryMacAddressInternal, hidl_status_cb);
+}
+
+Return<void> WifiApIface::getBridgedInstances(getBridgedInstances_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiApIface::getBridgedInstancesInternal, hidl_status_cb);
+}
+
+std::pair<WifiStatus, std::string> WifiApIface::getNameInternal() {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
+}
+
+std::pair<WifiStatus, IfaceType> WifiApIface::getTypeInternal() {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::AP};
+}
+
+WifiStatus WifiApIface::setCountryCodeInternal(const std::array<int8_t, 2>& code) {
+    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setCountryCode(
+            instances_.size() > 0 ? instances_[0] : ifname_, code);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+std::pair<WifiStatus, std::vector<WifiChannelInMhz>>
+WifiApIface::getValidFrequenciesForBandInternal(V1_0::WifiBand band) {
+    static_assert(sizeof(WifiChannelInMhz) == sizeof(uint32_t), "Size mismatch");
+    legacy_hal::wifi_error legacy_status;
+    std::vector<uint32_t> valid_frequencies;
+    std::tie(legacy_status, valid_frequencies) = legacy_hal_.lock()->getValidFrequenciesForBand(
+            instances_.size() > 0 ? instances_[0] : ifname_,
+            hidl_struct_util::convertHidlWifiBandToLegacy(band));
+    return {createWifiStatusFromLegacyError(legacy_status), valid_frequencies};
+}
+
+WifiStatus WifiApIface::setMacAddressInternal(const std::array<uint8_t, 6>& mac) {
+    // Support random MAC up to 2 interfaces
+    if (instances_.size() == 2) {
+        int rbyte = 1;
+        for (auto const& intf : instances_) {
+            std::array<uint8_t, 6> rmac = mac;
+            // reverse the bits to avoid collision
+            rmac[rbyte] = 0xff - rmac[rbyte];
+            if (!iface_util_.lock()->setMacAddress(intf, rmac)) {
+                LOG(INFO) << "Failed to set random mac address on " << intf;
+                return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+            }
+            rbyte++;
+        }
+    }
+    // It also needs to set mac address for bridged interface, otherwise the mac
+    // address of bridged interface will be changed after one of instance
+    // down.
+    if (!iface_util_.lock()->setMacAddress(ifname_, mac)) {
+        LOG(ERROR) << "Fail to config MAC for interface " << ifname_;
+        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+    }
+    return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, std::array<uint8_t, 6>> WifiApIface::getFactoryMacAddressInternal(
+        const std::string& ifaceName) {
+    std::array<uint8_t, 6> mac = iface_util_.lock()->getFactoryMacAddress(ifaceName);
+    if (mac[0] == 0 && mac[1] == 0 && mac[2] == 0 && mac[3] == 0 && mac[4] == 0 && mac[5] == 0) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), mac};
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), mac};
+}
+
+WifiStatus WifiApIface::resetToFactoryMacAddressInternal() {
+    std::pair<WifiStatus, std::array<uint8_t, 6>> getMacResult;
+    if (instances_.size() == 2) {
+        for (auto const& intf : instances_) {
+            getMacResult = getFactoryMacAddressInternal(intf);
+            LOG(DEBUG) << "Reset MAC to factory MAC on " << intf;
+            if (getMacResult.first.code != WifiStatusCode::SUCCESS ||
+                !iface_util_.lock()->setMacAddress(intf, getMacResult.second)) {
+                return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+            }
+        }
+        // It needs to set mac address for bridged interface, otherwise the mac
+        // address of the bridged interface will be changed after one of the
+        // instance down. Thus we are generating a random MAC address for the
+        // bridged interface even if we got the request to reset the Factory
+        // MAC. Since the bridged interface is an internal interface for the
+        // operation of bpf and others networking operation.
+        if (!iface_util_.lock()->setMacAddress(ifname_,
+                                               iface_util_.lock()->createRandomMacAddress())) {
+            LOG(ERROR) << "Fail to config MAC for bridged interface " << ifname_;
+            return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+        }
+    } else {
+        getMacResult = getFactoryMacAddressInternal(ifname_);
+        LOG(DEBUG) << "Reset MAC to factory MAC on " << ifname_;
+        if (getMacResult.first.code != WifiStatusCode::SUCCESS ||
+            !iface_util_.lock()->setMacAddress(ifname_, getMacResult.second)) {
+            return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+        }
+    }
+    return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, std::vector<hidl_string>> WifiApIface::getBridgedInstancesInternal() {
+    std::vector<hidl_string> instances;
+    for (const auto& instance_name : instances_) {
+        instances.push_back(instance_name);
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), instances};
+}
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
diff --git a/wifi/1.6/default/wifi_ap_iface.h b/wifi/1.6/default/wifi_ap_iface.h
new file mode 100644
index 0000000..d1c0642
--- /dev/null
+++ b/wifi/1.6/default/wifi_ap_iface.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WIFI_AP_IFACE_H_
+#define WIFI_AP_IFACE_H_
+
+#include <android-base/macros.h>
+#include <android/hardware/wifi/1.5/IWifiApIface.h>
+
+#include "wifi_iface_util.h"
+#include "wifi_legacy_hal.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+using namespace android::hardware::wifi::V1_0;
+
+/**
+ * HIDL interface object used to control a AP Iface instance.
+ */
+class WifiApIface : public V1_5::IWifiApIface {
+  public:
+    WifiApIface(const std::string& ifname, const std::vector<std::string>& instances,
+                const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
+                const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
+    // Refer to |WifiChip::invalidate()|.
+    void invalidate();
+    bool isValid();
+    std::string getName();
+    void removeInstance(std::string instance);
+
+    // HIDL methods exposed.
+    Return<void> getName(getName_cb hidl_status_cb) override;
+    Return<void> getType(getType_cb hidl_status_cb) override;
+    Return<void> setCountryCode(const hidl_array<int8_t, 2>& code,
+                                setCountryCode_cb hidl_status_cb) override;
+    Return<void> getValidFrequenciesForBand(V1_0::WifiBand band,
+                                            getValidFrequenciesForBand_cb hidl_status_cb) override;
+    Return<void> setMacAddress(const hidl_array<uint8_t, 6>& mac,
+                               setMacAddress_cb hidl_status_cb) override;
+    Return<void> getFactoryMacAddress(getFactoryMacAddress_cb hidl_status_cb) override;
+    Return<void> resetToFactoryMacAddress(resetToFactoryMacAddress_cb hidl_status_cb) override;
+
+    Return<void> getBridgedInstances(getBridgedInstances_cb hidl_status_cb) override;
+
+  private:
+    // Corresponding worker functions for the HIDL methods.
+    std::pair<WifiStatus, std::string> getNameInternal();
+    std::pair<WifiStatus, IfaceType> getTypeInternal();
+    WifiStatus setCountryCodeInternal(const std::array<int8_t, 2>& code);
+    std::pair<WifiStatus, std::vector<WifiChannelInMhz>> getValidFrequenciesForBandInternal(
+            V1_0::WifiBand band);
+    WifiStatus setMacAddressInternal(const std::array<uint8_t, 6>& mac);
+    std::pair<WifiStatus, std::array<uint8_t, 6>> getFactoryMacAddressInternal(
+            const std::string& ifaceName);
+    WifiStatus resetToFactoryMacAddressInternal();
+    std::pair<WifiStatus, std::vector<hidl_string>> getBridgedInstancesInternal();
+
+    std::string ifname_;
+    std::vector<std::string> instances_;
+    std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
+    std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
+    bool is_valid_;
+
+    DISALLOW_COPY_AND_ASSIGN(WifiApIface);
+};
+
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
+
+#endif  // WIFI_AP_IFACE_H_
diff --git a/wifi/aidl/default/wifi_chip.cpp b/wifi/1.6/default/wifi_chip.cpp
similarity index 63%
rename from wifi/aidl/default/wifi_chip.cpp
rename to wifi/1.6/default/wifi_chip.cpp
index 076f351..920beb8 100644
--- a/wifi/aidl/default/wifi_chip.cpp
+++ b/wifi/1.6/default/wifi_chip.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,27 +14,30 @@
  * limitations under the License.
  */
 
-#include "wifi_chip.h"
+#include <fcntl.h>
 
 #include <android-base/logging.h>
 #include <android-base/unique_fd.h>
 #include <cutils/properties.h>
-#include <fcntl.h>
 #include <net/if.h>
 #include <sys/stat.h>
 #include <sys/sysmacros.h>
 
-#include "aidl_return_util.h"
-#include "aidl_struct_util.h"
+#include "hidl_return_util.h"
+#include "hidl_struct_util.h"
+#include "wifi_chip.h"
 #include "wifi_status_util.h"
 
 #define P2P_MGMT_DEVICE_PREFIX "p2p-dev-"
 
 namespace {
-using aidl::android::hardware::wifi::IfaceType;
-using aidl::android::hardware::wifi::IWifiChip;
-using CoexRestriction = aidl::android::hardware::wifi::IWifiChip::CoexRestriction;
+using android::sp;
 using android::base::unique_fd;
+using android::hardware::hidl_string;
+using android::hardware::hidl_vec;
+using android::hardware::wifi::V1_0::ChipModeId;
+using android::hardware::wifi::V1_0::IfaceType;
+using android::hardware::wifi::V1_0::IWifiChip;
 
 constexpr char kCpioMagic[] = "070701";
 constexpr size_t kMaxBufferSizeBytes = 1024 * 1024 * 3;
@@ -47,13 +50,13 @@
 constexpr char kApBridgeIfacePrefix[] = "ap_br_";
 
 template <typename Iface>
-void invalidateAndClear(std::vector<std::shared_ptr<Iface>>& ifaces, std::shared_ptr<Iface> iface) {
+void invalidateAndClear(std::vector<sp<Iface>>& ifaces, sp<Iface> iface) {
     iface->invalidate();
     ifaces.erase(std::remove(ifaces.begin(), ifaces.end(), iface), ifaces.end());
 }
 
 template <typename Iface>
-void invalidateAndClearAll(std::vector<std::shared_ptr<Iface>>& ifaces) {
+void invalidateAndClearAll(std::vector<sp<Iface>>& ifaces) {
     for (const auto& iface : ifaces) {
         iface->invalidate();
     }
@@ -61,8 +64,8 @@
 }
 
 template <typename Iface>
-std::vector<std::string> getNames(std::vector<std::shared_ptr<Iface>>& ifaces) {
-    std::vector<std::string> names;
+std::vector<hidl_string> getNames(std::vector<sp<Iface>>& ifaces) {
+    std::vector<hidl_string> names;
     for (const auto& iface : ifaces) {
         names.emplace_back(iface->getName());
     }
@@ -70,9 +73,8 @@
 }
 
 template <typename Iface>
-std::shared_ptr<Iface> findUsingName(std::vector<std::shared_ptr<Iface>>& ifaces,
-                                     const std::string& name) {
-    std::vector<std::string> names;
+sp<Iface> findUsingName(std::vector<sp<Iface>>& ifaces, const std::string& name) {
+    std::vector<hidl_string> names;
     for (const auto& iface : ifaces) {
         if (name == iface->getName()) {
             return iface;
@@ -167,8 +169,8 @@
     }
 }
 
-// Delete files that meet either condition:
-// 1. Older than a predefined time in the wifi tombstone dir.
+// delete files that meet either conditions:
+// 1. older than a predefined time in the wifi tombstone dir.
 // 2. Files in excess to a predefined amount, starting from the oldest ones
 bool removeOldFilesInternal() {
     time_t now = time(0);
@@ -352,14 +354,15 @@
 
 }  // namespace
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
-using aidl_return_util::validateAndCall;
-using aidl_return_util::validateAndCallWithLock;
+namespace V1_6 {
+namespace implementation {
+using hidl_return_util::validateAndCall;
+using hidl_return_util::validateAndCallWithLock;
 
-WifiChip::WifiChip(int32_t chip_id, bool is_primary,
+WifiChip::WifiChip(ChipId chip_id, bool is_primary,
                    const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
                    const std::weak_ptr<mode_controller::WifiModeController> mode_controller,
                    const std::shared_ptr<iface_util::WifiIfaceUtil> iface_util,
@@ -377,19 +380,6 @@
     setActiveWlanIfaceNameProperty(kNoActiveWlanIfaceNamePropertyValue);
 }
 
-std::shared_ptr<WifiChip> WifiChip::create(
-        int32_t chip_id, bool is_primary, const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-        const std::weak_ptr<mode_controller::WifiModeController> mode_controller,
-        const std::shared_ptr<iface_util::WifiIfaceUtil> iface_util,
-        const std::weak_ptr<feature_flags::WifiFeatureFlags> feature_flags,
-        const std::function<void(const std::string&)>& handler) {
-    std::shared_ptr<WifiChip> ptr = ndk::SharedRefBase::make<WifiChip>(
-            chip_id, is_primary, legacy_hal, mode_controller, iface_util, feature_flags, handler);
-    std::weak_ptr<WifiChip> weak_ptr_this(ptr);
-    ptr->setWeakPtr(weak_ptr_this);
-    return ptr;
-}
-
 void WifiChip::invalidate() {
     if (!writeRingbufferFilesInternal()) {
         LOG(ERROR) << "Error writing files to flash";
@@ -401,283 +391,348 @@
     is_valid_ = false;
 }
 
-void WifiChip::setWeakPtr(std::weak_ptr<WifiChip> ptr) {
-    weak_ptr_this_ = ptr;
-}
-
 bool WifiChip::isValid() {
     return is_valid_;
 }
 
-std::set<std::shared_ptr<IWifiChipEventCallback>> WifiChip::getEventCallbacks() {
+std::set<sp<V1_4::IWifiChipEventCallback>> WifiChip::getEventCallbacks() {
     return event_cb_handler_.getCallbacks();
 }
 
-ndk::ScopedAStatus WifiChip::getId(int32_t* _aidl_return) {
+Return<void> WifiChip::getId(getId_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID, &WifiChip::getIdInternal,
-                           _aidl_return);
+                           hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::registerEventCallback(
-        const std::shared_ptr<IWifiChipEventCallback>& event_callback) {
+// Deprecated support for this callback
+Return<void> WifiChip::registerEventCallback(const sp<V1_0::IWifiChipEventCallback>& event_callback,
+                                             registerEventCallback_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::registerEventCallbackInternal, event_callback);
+                           &WifiChip::registerEventCallbackInternal, hidl_status_cb,
+                           event_callback);
 }
 
-ndk::ScopedAStatus WifiChip::getCapabilities(IWifiChip::ChipCapabilityMask* _aidl_return) {
+Return<void> WifiChip::getCapabilities(getCapabilities_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getCapabilitiesInternal, _aidl_return);
+                           &WifiChip::getCapabilitiesInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::getAvailableModes(std::vector<IWifiChip::ChipMode>* _aidl_return) {
+Return<void> WifiChip::getAvailableModes(getAvailableModes_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getAvailableModesInternal, _aidl_return);
+                           &WifiChip::getAvailableModesInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::configureChip(int32_t in_modeId) {
+Return<void> WifiChip::configureChip(ChipModeId mode_id, configureChip_cb hidl_status_cb) {
     return validateAndCallWithLock(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                                   &WifiChip::configureChipInternal, in_modeId);
+                                   &WifiChip::configureChipInternal, hidl_status_cb, mode_id);
 }
 
-ndk::ScopedAStatus WifiChip::getMode(int32_t* _aidl_return) {
+Return<void> WifiChip::getMode(getMode_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getModeInternal, _aidl_return);
+                           &WifiChip::getModeInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::requestChipDebugInfo(IWifiChip::ChipDebugInfo* _aidl_return) {
+Return<void> WifiChip::requestChipDebugInfo(requestChipDebugInfo_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::requestChipDebugInfoInternal, _aidl_return);
+                           &WifiChip::requestChipDebugInfoInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::requestDriverDebugDump(std::vector<uint8_t>* _aidl_return) {
+Return<void> WifiChip::requestDriverDebugDump(requestDriverDebugDump_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::requestDriverDebugDumpInternal, _aidl_return);
+                           &WifiChip::requestDriverDebugDumpInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::requestFirmwareDebugDump(std::vector<uint8_t>* _aidl_return) {
+Return<void> WifiChip::requestFirmwareDebugDump(requestFirmwareDebugDump_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::requestFirmwareDebugDumpInternal, _aidl_return);
+                           &WifiChip::requestFirmwareDebugDumpInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::createApIface(std::shared_ptr<IWifiApIface>* _aidl_return) {
+Return<void> WifiChip::createApIface(createApIface_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::createApIfaceInternal, _aidl_return);
+                           &WifiChip::createApIfaceInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::createBridgedApIface(std::shared_ptr<IWifiApIface>* _aidl_return) {
+Return<void> WifiChip::createBridgedApIface(createBridgedApIface_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::createBridgedApIfaceInternal, _aidl_return);
+                           &WifiChip::createBridgedApIfaceInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::getApIfaceNames(std::vector<std::string>* _aidl_return) {
+Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getApIfaceNamesInternal, _aidl_return);
+                           &WifiChip::getApIfaceNamesInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::getApIface(const std::string& in_ifname,
-                                        std::shared_ptr<IWifiApIface>* _aidl_return) {
+Return<void> WifiChip::getApIface(const hidl_string& ifname, getApIface_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getApIfaceInternal, _aidl_return, in_ifname);
+                           &WifiChip::getApIfaceInternal, hidl_status_cb, ifname);
 }
 
-ndk::ScopedAStatus WifiChip::removeApIface(const std::string& in_ifname) {
+Return<void> WifiChip::removeApIface(const hidl_string& ifname, removeApIface_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::removeApIfaceInternal, in_ifname);
+                           &WifiChip::removeApIfaceInternal, hidl_status_cb, ifname);
 }
 
-ndk::ScopedAStatus WifiChip::removeIfaceInstanceFromBridgedApIface(
-        const std::string& in_brIfaceName, const std::string& in_ifaceInstanceName) {
+Return<void> WifiChip::removeIfaceInstanceFromBridgedApIface(
+        const hidl_string& ifname, const hidl_string& ifInstanceName,
+        removeIfaceInstanceFromBridgedApIface_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::removeIfaceInstanceFromBridgedApIfaceInternal, in_brIfaceName,
-                           in_ifaceInstanceName);
+                           &WifiChip::removeIfaceInstanceFromBridgedApIfaceInternal, hidl_status_cb,
+                           ifname, ifInstanceName);
 }
 
-ndk::ScopedAStatus WifiChip::createNanIface(std::shared_ptr<IWifiNanIface>* _aidl_return) {
+Return<void> WifiChip::createNanIface(createNanIface_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::createNanIfaceInternal, _aidl_return);
+                           &WifiChip::createNanIfaceInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::getNanIfaceNames(std::vector<std::string>* _aidl_return) {
+Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getNanIfaceNamesInternal, _aidl_return);
+                           &WifiChip::getNanIfaceNamesInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::getNanIface(const std::string& in_ifname,
-                                         std::shared_ptr<IWifiNanIface>* _aidl_return) {
+Return<void> WifiChip::getNanIface(const hidl_string& ifname, getNanIface_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getNanIfaceInternal, _aidl_return, in_ifname);
+                           &WifiChip::getNanIfaceInternal, hidl_status_cb, ifname);
 }
 
-ndk::ScopedAStatus WifiChip::removeNanIface(const std::string& in_ifname) {
+Return<void> WifiChip::removeNanIface(const hidl_string& ifname, removeNanIface_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::removeNanIfaceInternal, in_ifname);
+                           &WifiChip::removeNanIfaceInternal, hidl_status_cb, ifname);
 }
 
-ndk::ScopedAStatus WifiChip::createP2pIface(std::shared_ptr<IWifiP2pIface>* _aidl_return) {
+Return<void> WifiChip::createP2pIface(createP2pIface_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::createP2pIfaceInternal, _aidl_return);
+                           &WifiChip::createP2pIfaceInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::getP2pIfaceNames(std::vector<std::string>* _aidl_return) {
+Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getP2pIfaceNamesInternal, _aidl_return);
+                           &WifiChip::getP2pIfaceNamesInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::getP2pIface(const std::string& in_ifname,
-                                         std::shared_ptr<IWifiP2pIface>* _aidl_return) {
+Return<void> WifiChip::getP2pIface(const hidl_string& ifname, getP2pIface_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getP2pIfaceInternal, _aidl_return, in_ifname);
+                           &WifiChip::getP2pIfaceInternal, hidl_status_cb, ifname);
 }
 
-ndk::ScopedAStatus WifiChip::removeP2pIface(const std::string& in_ifname) {
+Return<void> WifiChip::removeP2pIface(const hidl_string& ifname, removeP2pIface_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::removeP2pIfaceInternal, in_ifname);
+                           &WifiChip::removeP2pIfaceInternal, hidl_status_cb, ifname);
 }
 
-ndk::ScopedAStatus WifiChip::createStaIface(std::shared_ptr<IWifiStaIface>* _aidl_return) {
+Return<void> WifiChip::createStaIface(createStaIface_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::createStaIfaceInternal, _aidl_return);
+                           &WifiChip::createStaIfaceInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::getStaIfaceNames(std::vector<std::string>* _aidl_return) {
+Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getStaIfaceNamesInternal, _aidl_return);
+                           &WifiChip::getStaIfaceNamesInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::getStaIface(const std::string& in_ifname,
-                                         std::shared_ptr<IWifiStaIface>* _aidl_return) {
+Return<void> WifiChip::getStaIface(const hidl_string& ifname, getStaIface_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getStaIfaceInternal, _aidl_return, in_ifname);
+                           &WifiChip::getStaIfaceInternal, hidl_status_cb, ifname);
 }
 
-ndk::ScopedAStatus WifiChip::removeStaIface(const std::string& in_ifname) {
+Return<void> WifiChip::removeStaIface(const hidl_string& ifname, removeStaIface_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::removeStaIfaceInternal, in_ifname);
+                           &WifiChip::removeStaIfaceInternal, hidl_status_cb, ifname);
 }
 
-ndk::ScopedAStatus WifiChip::createRttController(
-        const std::shared_ptr<IWifiStaIface>& in_boundIface,
-        std::shared_ptr<IWifiRttController>* _aidl_return) {
+Return<void> WifiChip::createRttController(const sp<IWifiIface>& bound_iface,
+                                           createRttController_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::createRttControllerInternal, _aidl_return, in_boundIface);
+                           &WifiChip::createRttControllerInternal, hidl_status_cb, bound_iface);
 }
 
-ndk::ScopedAStatus WifiChip::getDebugRingBuffersStatus(
-        std::vector<WifiDebugRingBufferStatus>* _aidl_return) {
+Return<void> WifiChip::getDebugRingBuffersStatus(getDebugRingBuffersStatus_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getDebugRingBuffersStatusInternal, _aidl_return);
+                           &WifiChip::getDebugRingBuffersStatusInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::startLoggingToDebugRingBuffer(
-        const std::string& in_ringName, WifiDebugRingBufferVerboseLevel in_verboseLevel,
-        int32_t in_maxIntervalInSec, int32_t in_minDataSizeInBytes) {
+Return<void> WifiChip::startLoggingToDebugRingBuffer(
+        const hidl_string& ring_name, WifiDebugRingBufferVerboseLevel verbose_level,
+        uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes,
+        startLoggingToDebugRingBuffer_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::startLoggingToDebugRingBufferInternal, in_ringName,
-                           in_verboseLevel, in_maxIntervalInSec, in_minDataSizeInBytes);
+                           &WifiChip::startLoggingToDebugRingBufferInternal, hidl_status_cb,
+                           ring_name, verbose_level, max_interval_in_sec, min_data_size_in_bytes);
 }
 
-ndk::ScopedAStatus WifiChip::forceDumpToDebugRingBuffer(const std::string& in_ringName) {
+Return<void> WifiChip::forceDumpToDebugRingBuffer(const hidl_string& ring_name,
+                                                  forceDumpToDebugRingBuffer_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::forceDumpToDebugRingBufferInternal, in_ringName);
+                           &WifiChip::forceDumpToDebugRingBufferInternal, hidl_status_cb,
+                           ring_name);
 }
 
-ndk::ScopedAStatus WifiChip::flushRingBufferToFile() {
+Return<void> WifiChip::flushRingBufferToFile(flushRingBufferToFile_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::flushRingBufferToFileInternal);
+                           &WifiChip::flushRingBufferToFileInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::stopLoggingToDebugRingBuffer() {
+Return<void> WifiChip::stopLoggingToDebugRingBuffer(
+        stopLoggingToDebugRingBuffer_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::stopLoggingToDebugRingBufferInternal);
+                           &WifiChip::stopLoggingToDebugRingBufferInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::getDebugHostWakeReasonStats(
-        WifiDebugHostWakeReasonStats* _aidl_return) {
+Return<void> WifiChip::getDebugHostWakeReasonStats(getDebugHostWakeReasonStats_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getDebugHostWakeReasonStatsInternal, _aidl_return);
+                           &WifiChip::getDebugHostWakeReasonStatsInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::enableDebugErrorAlerts(bool in_enable) {
+Return<void> WifiChip::enableDebugErrorAlerts(bool enable,
+                                              enableDebugErrorAlerts_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::enableDebugErrorAlertsInternal, in_enable);
+                           &WifiChip::enableDebugErrorAlertsInternal, hidl_status_cb, enable);
 }
 
-ndk::ScopedAStatus WifiChip::selectTxPowerScenario(IWifiChip::TxPowerScenario in_scenario) {
+Return<void> WifiChip::selectTxPowerScenario(V1_1::IWifiChip::TxPowerScenario scenario,
+                                             selectTxPowerScenario_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::selectTxPowerScenarioInternal, in_scenario);
+                           &WifiChip::selectTxPowerScenarioInternal, hidl_status_cb, scenario);
 }
 
-ndk::ScopedAStatus WifiChip::resetTxPowerScenario() {
+Return<void> WifiChip::resetTxPowerScenario(resetTxPowerScenario_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::resetTxPowerScenarioInternal);
+                           &WifiChip::resetTxPowerScenarioInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::setLatencyMode(IWifiChip::LatencyMode in_mode) {
+Return<void> WifiChip::setLatencyMode(LatencyMode mode, setLatencyMode_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::setLatencyModeInternal, in_mode);
+                           &WifiChip::setLatencyModeInternal, hidl_status_cb, mode);
 }
 
-binder_status_t WifiChip::dump(int fd, const char**, uint32_t) {
-    {
-        std::unique_lock<std::mutex> lk(lock_t);
-        for (const auto& item : ringbuffer_map_) {
-            forceDumpToDebugRingBufferInternal(item.first);
+Return<void> WifiChip::registerEventCallback_1_2(
+        const sp<V1_2::IWifiChipEventCallback>& event_callback,
+        registerEventCallback_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                           &WifiChip::registerEventCallbackInternal_1_2, hidl_status_cb,
+                           event_callback);
+}
+
+Return<void> WifiChip::selectTxPowerScenario_1_2(TxPowerScenario scenario,
+                                                 selectTxPowerScenario_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                           &WifiChip::selectTxPowerScenarioInternal_1_2, hidl_status_cb, scenario);
+}
+
+Return<void> WifiChip::getCapabilities_1_3(getCapabilities_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                           &WifiChip::getCapabilitiesInternal_1_3, hidl_status_cb);
+}
+
+Return<void> WifiChip::getCapabilities_1_5(getCapabilities_1_5_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                           &WifiChip::getCapabilitiesInternal_1_5, hidl_status_cb);
+}
+
+Return<void> WifiChip::debug(const hidl_handle& handle, const hidl_vec<hidl_string>&) {
+    if (handle != nullptr && handle->numFds >= 1) {
+        {
+            std::unique_lock<std::mutex> lk(lock_t);
+            for (const auto& item : ringbuffer_map_) {
+                forceDumpToDebugRingBufferInternal(item.first);
+            }
+            // unique_lock unlocked here
         }
-        // unique_lock unlocked here
+        usleep(100 * 1000);  // sleep for 100 milliseconds to wait for
+                             // ringbuffer updates.
+        int fd = handle->data[0];
+        if (!writeRingbufferFilesInternal()) {
+            LOG(ERROR) << "Error writing files to flash";
+        }
+        uint32_t n_error = cpioArchiveFilesInDir(fd, kTombstoneFolderPath);
+        if (n_error != 0) {
+            LOG(ERROR) << n_error << " errors occured in cpio function";
+        }
+        fsync(fd);
+    } else {
+        LOG(ERROR) << "File handle error";
     }
-    usleep(100 * 1000);  // sleep for 100 milliseconds to wait for
-                         // ringbuffer updates.
-    if (!writeRingbufferFilesInternal()) {
-        LOG(ERROR) << "Error writing files to flash";
-    }
-    uint32_t n_error = cpioArchiveFilesInDir(fd, kTombstoneFolderPath);
-    if (n_error != 0) {
-        LOG(ERROR) << n_error << " errors occurred in cpio function";
-    }
-    fsync(fd);
-    return STATUS_OK;
+    return Void();
 }
 
-ndk::ScopedAStatus WifiChip::setMultiStaPrimaryConnection(const std::string& in_ifName) {
+Return<void> WifiChip::createRttController_1_4(const sp<IWifiIface>& bound_iface,
+                                               createRttController_1_4_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::setMultiStaPrimaryConnectionInternal, in_ifName);
+                           &WifiChip::createRttControllerInternal_1_4, hidl_status_cb, bound_iface);
 }
 
-ndk::ScopedAStatus WifiChip::setMultiStaUseCase(IWifiChip::MultiStaUseCase in_useCase) {
+Return<void> WifiChip::registerEventCallback_1_4(
+        const sp<V1_4::IWifiChipEventCallback>& event_callback,
+        registerEventCallback_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::setMultiStaUseCaseInternal, in_useCase);
+                           &WifiChip::registerEventCallbackInternal_1_4, hidl_status_cb,
+                           event_callback);
 }
 
-ndk::ScopedAStatus WifiChip::setCoexUnsafeChannels(
-        const std::vector<IWifiChip::CoexUnsafeChannel>& in_unsafeChannels,
-        CoexRestriction in_restrictions) {
+Return<void> WifiChip::setMultiStaPrimaryConnection(
+        const hidl_string& ifname, setMultiStaPrimaryConnection_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::setCoexUnsafeChannelsInternal, in_unsafeChannels,
-                           in_restrictions);
+                           &WifiChip::setMultiStaPrimaryConnectionInternal, hidl_status_cb, ifname);
 }
 
-ndk::ScopedAStatus WifiChip::setCountryCode(const std::array<uint8_t, 2>& in_code) {
+Return<void> WifiChip::setMultiStaUseCase(MultiStaUseCase use_case,
+                                          setMultiStaUseCase_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                           &WifiChip::setMultiStaUseCaseInternal, hidl_status_cb, use_case);
+}
+
+Return<void> WifiChip::setCoexUnsafeChannels(const hidl_vec<CoexUnsafeChannel>& unsafeChannels,
+                                             hidl_bitfield<CoexRestriction> restrictions,
+                                             setCoexUnsafeChannels_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                           &WifiChip::setCoexUnsafeChannelsInternal, hidl_status_cb, unsafeChannels,
+                           restrictions);
+}
+
+Return<void> WifiChip::setCountryCode(const hidl_array<int8_t, 2>& code,
+                                      setCountryCode_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiChip::setCountryCodeInternal, in_code);
+                           &WifiChip::setCountryCodeInternal, hidl_status_cb, code);
 }
 
-ndk::ScopedAStatus WifiChip::getUsableChannels(WifiBand in_band, WifiIfaceMode in_ifaceModeMask,
-                                               UsableChannelFilter in_filterMask,
-                                               std::vector<WifiUsableChannel>* _aidl_return) {
+Return<void> WifiChip::getUsableChannels(
+        WifiBand band, hidl_bitfield<V1_5::WifiIfaceMode> ifaceModeMask,
+        hidl_bitfield<V1_5::IWifiChip::UsableChannelFilter> filterMask,
+        getUsableChannels_cb _hidl_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getUsableChannelsInternal, _aidl_return, in_band,
-                           in_ifaceModeMask, in_filterMask);
+                           &WifiChip::getUsableChannelsInternal, _hidl_cb, band, ifaceModeMask,
+                           filterMask);
 }
 
-ndk::ScopedAStatus WifiChip::triggerSubsystemRestart() {
+Return<void> WifiChip::triggerSubsystemRestart(triggerSubsystemRestart_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::triggerSubsystemRestartInternal);
+                           &WifiChip::triggerSubsystemRestartInternal, hidl_status_cb);
 }
 
-ndk::ScopedAStatus WifiChip::getSupportedRadioCombinationsMatrix(
-        WifiRadioCombinationMatrix* _aidl_return) {
+Return<void> WifiChip::createRttController_1_6(const sp<IWifiIface>& bound_iface,
+                                               createRttController_1_6_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getSupportedRadioCombinationsMatrixInternal, _aidl_return);
+                           &WifiChip::createRttControllerInternal_1_6, hidl_status_cb, bound_iface);
+}
+
+Return<void> WifiChip::getUsableChannels_1_6(
+        WifiBand band, hidl_bitfield<V1_5::WifiIfaceMode> ifaceModeMask,
+        hidl_bitfield<V1_6::IWifiChip::UsableChannelFilter> filterMask,
+        getUsableChannels_1_6_cb _hidl_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                           &WifiChip::getUsableChannelsInternal_1_6, _hidl_cb, band, ifaceModeMask,
+                           filterMask);
+}
+
+Return<void> WifiChip::getSupportedRadioCombinationsMatrix(
+        getSupportedRadioCombinationsMatrix_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                           &WifiChip::getSupportedRadioCombinationsMatrixInternal, hidl_status_cb);
+}
+
+Return<void> WifiChip::getAvailableModes_1_6(getAvailableModes_1_6_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                           &WifiChip::getAvailableModesInternal_1_6, hidl_status_cb);
 }
 
 void WifiChip::invalidateAndRemoveAllIfaces() {
@@ -700,7 +755,7 @@
         if (nan_iface->getName() == removed_iface_name) {
             nan_iface->invalidate();
             for (const auto& callback : event_cb_handler_.getCallbacks()) {
-                if (!callback->onIfaceRemoved(IfaceType::NAN_IFACE, removed_iface_name).isOk()) {
+                if (!callback->onIfaceRemoved(IfaceType::NAN, removed_iface_name).isOk()) {
                     LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
                 }
             }
@@ -721,61 +776,89 @@
     }
 }
 
-std::pair<int32_t, ndk::ScopedAStatus> WifiChip::getIdInternal() {
-    return {chip_id_, ndk::ScopedAStatus::ok()};
+std::pair<WifiStatus, ChipId> WifiChip::getIdInternal() {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), chip_id_};
 }
 
-ndk::ScopedAStatus WifiChip::registerEventCallbackInternal(
-        const std::shared_ptr<IWifiChipEventCallback>& event_callback) {
-    if (!event_cb_handler_.addCallback(event_callback)) {
-        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
-    }
-    return ndk::ScopedAStatus::ok();
+WifiStatus WifiChip::registerEventCallbackInternal(
+        const sp<V1_0::IWifiChipEventCallback>& /* event_callback */) {
+    // Deprecated support for this callback.
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
 }
 
-std::pair<IWifiChip::ChipCapabilityMask, ndk::ScopedAStatus> WifiChip::getCapabilitiesInternal() {
-    legacy_hal::wifi_error legacy_status;
-    uint64_t legacy_feature_set;
-    uint32_t legacy_logger_feature_set;
-    const auto ifname = getFirstActiveWlanIfaceName();
-    std::tie(legacy_status, legacy_feature_set) =
-            legacy_hal_.lock()->getSupportedFeatureSet(ifname);
-    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
-        return {IWifiChip::ChipCapabilityMask{}, createWifiStatusFromLegacyError(legacy_status)};
-    }
-    std::tie(legacy_status, legacy_logger_feature_set) =
-            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;
-    }
-    uint32_t aidl_caps;
-    if (!aidl_struct_util::convertLegacyFeaturesToAidlChipCapabilities(
-                legacy_feature_set, legacy_logger_feature_set, &aidl_caps)) {
-        return {IWifiChip::ChipCapabilityMask{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
-    }
-    return {static_cast<IWifiChip::ChipCapabilityMask>(aidl_caps), ndk::ScopedAStatus::ok()};
+std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal() {
+    // Deprecated support for this callback.
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), 0};
 }
 
-std::pair<std::vector<IWifiChip::ChipMode>, ndk::ScopedAStatus>
+std::pair<WifiStatus, std::vector<V1_0::IWifiChip::ChipMode>>
 WifiChip::getAvailableModesInternal() {
-    return {modes_, ndk::ScopedAStatus::ok()};
+    // Deprecated support -- use getAvailableModes_1_6 for more granular concurrency combinations.
+    std::vector<V1_0::IWifiChip::ChipMode> modes_1_0 = {};
+    for (const auto& mode_1_6 : modes_) {
+        std::vector<V1_0::IWifiChip::ChipIfaceCombination> combos_1_0;
+        for (const auto& combo_1_6 : mode_1_6.availableCombinations) {
+            std::vector<V1_0::IWifiChip::ChipIfaceCombinationLimit> limits_1_0;
+            for (const auto& limit_1_6 : combo_1_6.limits) {
+                std::vector<IfaceType> types_1_0;
+                for (IfaceConcurrencyType type_1_6 : limit_1_6.types) {
+                    switch (type_1_6) {
+                        case IfaceConcurrencyType::STA:
+                            types_1_0.push_back(IfaceType::STA);
+                            break;
+                        case IfaceConcurrencyType::AP:
+                            types_1_0.push_back(IfaceType::AP);
+                            break;
+                        case IfaceConcurrencyType::AP_BRIDGED:
+                            // Ignore AP_BRIDGED
+                            break;
+                        case IfaceConcurrencyType::P2P:
+                            types_1_0.push_back(IfaceType::P2P);
+                            break;
+                        case IfaceConcurrencyType::NAN:
+                            types_1_0.push_back(IfaceType::NAN);
+                            break;
+                    }
+                }
+                if (types_1_0.empty()) {
+                    continue;
+                }
+                V1_0::IWifiChip::ChipIfaceCombinationLimit limit_1_0;
+                limit_1_0.types = hidl_vec(types_1_0);
+                limit_1_0.maxIfaces = limit_1_6.maxIfaces;
+                limits_1_0.push_back(limit_1_0);
+            }
+            if (limits_1_0.empty()) {
+                continue;
+            }
+            V1_0::IWifiChip::ChipIfaceCombination combo_1_0;
+            combo_1_0.limits = hidl_vec(limits_1_0);
+            combos_1_0.push_back(combo_1_0);
+        }
+        if (combos_1_0.empty()) {
+            continue;
+        }
+        V1_0::IWifiChip::ChipMode mode_1_0;
+        mode_1_0.id = mode_1_6.id;
+        mode_1_0.availableCombinations = hidl_vec(combos_1_0);
+        modes_1_0.push_back(mode_1_0);
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), modes_1_0};
 }
 
-ndk::ScopedAStatus WifiChip::configureChipInternal(
-        /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock, int32_t mode_id) {
+WifiStatus WifiChip::configureChipInternal(
+        /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock, ChipModeId mode_id) {
     if (!isValidModeId(mode_id)) {
         return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
     }
     if (mode_id == current_mode_id_) {
         LOG(DEBUG) << "Already in the specified mode " << mode_id;
-        return ndk::ScopedAStatus::ok();
+        return createWifiStatus(WifiStatusCode::SUCCESS);
     }
-    ndk::ScopedAStatus status = handleChipConfiguration(lock, mode_id);
-    if (!status.isOk()) {
-        WifiStatusCode errorCode = static_cast<WifiStatusCode>(status.getServiceSpecificError());
+    WifiStatus status = handleChipConfiguration(lock, mode_id);
+    if (status.code != WifiStatusCode::SUCCESS) {
         for (const auto& callback : event_cb_handler_.getCallbacks()) {
-            if (!callback->onChipReconfigureFailure(errorCode).isOk()) {
+            if (!callback->onChipReconfigureFailure(status).isOk()) {
                 LOG(ERROR) << "Failed to invoke onChipReconfigureFailure callback";
             }
         }
@@ -795,24 +878,24 @@
     return status;
 }
 
-std::pair<int32_t, ndk::ScopedAStatus> WifiChip::getModeInternal() {
+std::pair<WifiStatus, uint32_t> WifiChip::getModeInternal() {
     if (!isValidModeId(current_mode_id_)) {
-        return {current_mode_id_, createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE)};
+        return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), current_mode_id_};
     }
-    return {current_mode_id_, ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), current_mode_id_};
 }
 
-std::pair<IWifiChip::ChipDebugInfo, ndk::ScopedAStatus> WifiChip::requestChipDebugInfoInternal() {
-    IWifiChip::ChipDebugInfo result;
+std::pair<WifiStatus, V1_4::IWifiChip::ChipDebugInfo> WifiChip::requestChipDebugInfoInternal() {
+    V1_4::IWifiChip::ChipDebugInfo result;
     legacy_hal::wifi_error legacy_status;
     std::string driver_desc;
     const auto ifname = getFirstActiveWlanIfaceName();
     std::tie(legacy_status, driver_desc) = legacy_hal_.lock()->getDriverVersion(ifname);
     if (legacy_status != legacy_hal::WIFI_SUCCESS) {
         LOG(ERROR) << "Failed to get driver version: " << legacyErrorToString(legacy_status);
-        ndk::ScopedAStatus status =
+        WifiStatus status =
                 createWifiStatusFromLegacyError(legacy_status, "failed to get driver version");
-        return {std::move(result), std::move(status)};
+        return {status, result};
     }
     result.driverDescription = driver_desc.c_str();
 
@@ -820,60 +903,59 @@
     std::tie(legacy_status, firmware_desc) = legacy_hal_.lock()->getFirmwareVersion(ifname);
     if (legacy_status != legacy_hal::WIFI_SUCCESS) {
         LOG(ERROR) << "Failed to get firmware version: " << legacyErrorToString(legacy_status);
-        ndk::ScopedAStatus status =
+        WifiStatus status =
                 createWifiStatusFromLegacyError(legacy_status, "failed to get firmware version");
-        return {std::move(result), std::move(status)};
+        return {status, result};
     }
     result.firmwareDescription = firmware_desc.c_str();
 
-    return {std::move(result), ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), result};
 }
 
-std::pair<std::vector<uint8_t>, ndk::ScopedAStatus> WifiChip::requestDriverDebugDumpInternal() {
+std::pair<WifiStatus, std::vector<uint8_t>> WifiChip::requestDriverDebugDumpInternal() {
     legacy_hal::wifi_error legacy_status;
     std::vector<uint8_t> driver_dump;
     std::tie(legacy_status, driver_dump) =
             legacy_hal_.lock()->requestDriverMemoryDump(getFirstActiveWlanIfaceName());
     if (legacy_status != legacy_hal::WIFI_SUCCESS) {
         LOG(ERROR) << "Failed to get driver debug dump: " << legacyErrorToString(legacy_status);
-        return {std::vector<uint8_t>(), createWifiStatusFromLegacyError(legacy_status)};
+        return {createWifiStatusFromLegacyError(legacy_status), std::vector<uint8_t>()};
     }
-    return {driver_dump, ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), driver_dump};
 }
 
-std::pair<std::vector<uint8_t>, ndk::ScopedAStatus> WifiChip::requestFirmwareDebugDumpInternal() {
+std::pair<WifiStatus, std::vector<uint8_t>> WifiChip::requestFirmwareDebugDumpInternal() {
     legacy_hal::wifi_error legacy_status;
     std::vector<uint8_t> firmware_dump;
     std::tie(legacy_status, firmware_dump) =
             legacy_hal_.lock()->requestFirmwareMemoryDump(getFirstActiveWlanIfaceName());
     if (legacy_status != legacy_hal::WIFI_SUCCESS) {
         LOG(ERROR) << "Failed to get firmware debug dump: " << legacyErrorToString(legacy_status);
-        return {std::vector<uint8_t>(), createWifiStatusFromLegacyError(legacy_status)};
+        return {createWifiStatusFromLegacyError(legacy_status), {}};
     }
-    return {firmware_dump, ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), firmware_dump};
 }
 
-ndk::ScopedAStatus WifiChip::createVirtualApInterface(const std::string& apVirtIf) {
+WifiStatus WifiChip::createVirtualApInterface(const std::string& apVirtIf) {
     legacy_hal::wifi_error legacy_status;
     legacy_status = legacy_hal_.lock()->createVirtualInterface(
-            apVirtIf, aidl_struct_util::convertAidlIfaceTypeToLegacy(IfaceType::AP));
+            apVirtIf, hidl_struct_util::convertHidlIfaceTypeToLegacy(IfaceType::AP));
     if (legacy_status != legacy_hal::WIFI_SUCCESS) {
         LOG(ERROR) << "Failed to add interface: " << apVirtIf << " "
                    << legacyErrorToString(legacy_status);
         return createWifiStatusFromLegacyError(legacy_status);
     }
-    return ndk::ScopedAStatus::ok();
+    return createWifiStatus(WifiStatusCode::SUCCESS);
 }
 
-std::shared_ptr<WifiApIface> WifiChip::newWifiApIface(std::string& ifname) {
+sp<WifiApIface> WifiChip::newWifiApIface(std::string& ifname) {
     std::vector<std::string> ap_instances;
     for (auto const& it : br_ifaces_ap_instances_) {
         if (it.first == ifname) {
             ap_instances = it.second;
         }
     }
-    std::shared_ptr<WifiApIface> iface =
-            ndk::SharedRefBase::make<WifiApIface>(ifname, ap_instances, legacy_hal_, iface_util_);
+    sp<WifiApIface> iface = new WifiApIface(ifname, ap_instances, legacy_hal_, iface_util_);
     ap_ifaces_.push_back(iface);
     for (const auto& callback : event_cb_handler_.getCallbacks()) {
         if (!callback->onIfaceAdded(IfaceType::AP, ifname).isOk()) {
@@ -884,77 +966,75 @@
     return iface;
 }
 
-std::pair<std::shared_ptr<IWifiApIface>, ndk::ScopedAStatus> WifiChip::createApIfaceInternal() {
+std::pair<WifiStatus, sp<V1_5::IWifiApIface>> WifiChip::createApIfaceInternal() {
     if (!canCurrentModeSupportConcurrencyTypeWithCurrentTypes(IfaceConcurrencyType::AP)) {
-        return {std::shared_ptr<WifiApIface>(),
-                createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE)};
+        return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
     }
     std::string ifname = allocateApIfaceName();
-    ndk::ScopedAStatus status = createVirtualApInterface(ifname);
-    if (!status.isOk()) {
-        return {std::shared_ptr<WifiApIface>(), std::move(status)};
+    WifiStatus status = createVirtualApInterface(ifname);
+    if (status.code != WifiStatusCode::SUCCESS) {
+        return {status, {}};
     }
-    std::shared_ptr<WifiApIface> iface = newWifiApIface(ifname);
-    return {iface, ndk::ScopedAStatus::ok()};
+    sp<WifiApIface> iface = newWifiApIface(ifname);
+    return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
 }
 
-std::pair<std::shared_ptr<IWifiApIface>, ndk::ScopedAStatus>
-WifiChip::createBridgedApIfaceInternal() {
+std::pair<WifiStatus, sp<V1_5::IWifiApIface>> WifiChip::createBridgedApIfaceInternal() {
     if (!canCurrentModeSupportConcurrencyTypeWithCurrentTypes(IfaceConcurrencyType::AP_BRIDGED)) {
-        return {nullptr, createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE)};
+        return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
     }
     std::vector<std::string> ap_instances = allocateBridgedApInstanceNames();
     if (ap_instances.size() < 2) {
         LOG(ERROR) << "Fail to allocate two instances";
-        return {nullptr, createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE)};
+        return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
     }
     std::string br_ifname = kApBridgeIfacePrefix + ap_instances[0];
     for (int i = 0; i < 2; i++) {
-        ndk::ScopedAStatus status = createVirtualApInterface(ap_instances[i]);
-        if (!status.isOk()) {
+        WifiStatus status = createVirtualApInterface(ap_instances[i]);
+        if (status.code != WifiStatusCode::SUCCESS) {
             if (i != 0) {  // The failure happened when creating second virtual
                            // iface.
                 legacy_hal_.lock()->deleteVirtualInterface(
                         ap_instances.front());  // Remove the first virtual iface.
             }
-            return {nullptr, std::move(status)};
+            return {status, {}};
         }
     }
     br_ifaces_ap_instances_[br_ifname] = ap_instances;
     if (!iface_util_->createBridge(br_ifname)) {
         LOG(ERROR) << "Failed createBridge - br_name=" << br_ifname.c_str();
-        invalidateAndClearBridgedAp(br_ifname);
-        return {nullptr, createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE)};
+        deleteApIface(br_ifname);
+        return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
     }
     for (auto const& instance : ap_instances) {
         // Bind ap instance interface to AP bridge
         if (!iface_util_->addIfaceToBridge(br_ifname, instance)) {
             LOG(ERROR) << "Failed add if to Bridge - if_name=" << instance.c_str();
-            invalidateAndClearBridgedAp(br_ifname);
-            return {nullptr, createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE)};
+            deleteApIface(br_ifname);
+            return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
         }
     }
-    std::shared_ptr<WifiApIface> iface = newWifiApIface(br_ifname);
-    return {iface, ndk::ScopedAStatus::ok()};
+    sp<WifiApIface> iface = newWifiApIface(br_ifname);
+    return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
 }
 
-std::pair<std::vector<std::string>, ndk::ScopedAStatus> WifiChip::getApIfaceNamesInternal() {
+std::pair<WifiStatus, std::vector<hidl_string>> WifiChip::getApIfaceNamesInternal() {
     if (ap_ifaces_.empty()) {
-        return {std::vector<std::string>(), ndk::ScopedAStatus::ok()};
+        return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
     }
-    return {getNames(ap_ifaces_), ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(ap_ifaces_)};
 }
 
-std::pair<std::shared_ptr<IWifiApIface>, ndk::ScopedAStatus> WifiChip::getApIfaceInternal(
+std::pair<WifiStatus, sp<V1_5::IWifiApIface>> WifiChip::getApIfaceInternal(
         const std::string& ifname) {
     const auto iface = findUsingName(ap_ifaces_, ifname);
     if (!iface.get()) {
-        return {nullptr, createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS)};
+        return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
     }
-    return {iface, ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
 }
 
-ndk::ScopedAStatus WifiChip::removeApIfaceInternal(const std::string& ifname) {
+WifiStatus WifiChip::removeApIfaceInternal(const std::string& ifname) {
     const auto iface = findUsingName(ap_ifaces_, ifname);
     if (!iface.get()) {
         return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
@@ -964,8 +1044,7 @@
     // nan/rtt objects over AP iface. But, there is no harm to do it
     // here and not make that assumption all over the place.
     invalidateAndRemoveDependencies(ifname);
-    // Clear the bridge interface and the iface instance.
-    invalidateAndClearBridgedAp(ifname);
+    deleteApIface(ifname);
     invalidateAndClear(ap_ifaces_, iface);
     for (const auto& callback : event_cb_handler_.getCallbacks()) {
         if (!callback->onIfaceRemoved(IfaceType::AP, ifname).isOk()) {
@@ -973,10 +1052,10 @@
         }
     }
     setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
-    return ndk::ScopedAStatus::ok();
+    return createWifiStatus(WifiStatusCode::SUCCESS);
 }
 
-ndk::ScopedAStatus WifiChip::removeIfaceInstanceFromBridgedApIfaceInternal(
+WifiStatus WifiChip::removeIfaceInstanceFromBridgedApIfaceInternal(
         const std::string& ifname, const std::string& ifInstanceName) {
     const auto iface = findUsingName(ap_ifaces_, ifname);
     if (!iface.get() || ifInstanceName.empty()) {
@@ -1013,12 +1092,12 @@
     iface->removeInstance(ifInstanceName);
     setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
 
-    return ndk::ScopedAStatus::ok();
+    return createWifiStatus(WifiStatusCode::SUCCESS);
 }
 
-std::pair<std::shared_ptr<IWifiNanIface>, ndk::ScopedAStatus> WifiChip::createNanIfaceInternal() {
-    if (!canCurrentModeSupportConcurrencyTypeWithCurrentTypes(IfaceConcurrencyType::NAN_IFACE)) {
-        return {nullptr, createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE)};
+std::pair<WifiStatus, sp<V1_4::IWifiNanIface>> WifiChip::createNanIfaceInternal() {
+    if (!canCurrentModeSupportConcurrencyTypeWithCurrentTypes(IfaceConcurrencyType::NAN)) {
+        return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
     }
     bool is_dedicated_iface = true;
     std::string ifname = getPredefinedNanIfaceName();
@@ -1028,80 +1107,77 @@
         ifname = getFirstActiveWlanIfaceName();
         is_dedicated_iface = false;
     }
-    std::shared_ptr<WifiNanIface> iface =
-            WifiNanIface::create(ifname, is_dedicated_iface, legacy_hal_, iface_util_);
+    sp<WifiNanIface> iface = new WifiNanIface(ifname, is_dedicated_iface, legacy_hal_, iface_util_);
     nan_ifaces_.push_back(iface);
     for (const auto& callback : event_cb_handler_.getCallbacks()) {
-        if (!callback->onIfaceAdded(IfaceType::NAN_IFACE, ifname).isOk()) {
+        if (!callback->onIfaceAdded(IfaceType::NAN, ifname).isOk()) {
             LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
         }
     }
-    return {iface, ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
 }
 
-std::pair<std::vector<std::string>, ndk::ScopedAStatus> WifiChip::getNanIfaceNamesInternal() {
+std::pair<WifiStatus, std::vector<hidl_string>> WifiChip::getNanIfaceNamesInternal() {
     if (nan_ifaces_.empty()) {
-        return {std::vector<std::string>(), ndk::ScopedAStatus::ok()};
+        return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
     }
-    return {getNames(nan_ifaces_), ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(nan_ifaces_)};
 }
 
-std::pair<std::shared_ptr<IWifiNanIface>, ndk::ScopedAStatus> WifiChip::getNanIfaceInternal(
+std::pair<WifiStatus, sp<V1_4::IWifiNanIface>> WifiChip::getNanIfaceInternal(
         const std::string& ifname) {
     const auto iface = findUsingName(nan_ifaces_, ifname);
     if (!iface.get()) {
-        return {nullptr, createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS)};
+        return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
     }
-    return {iface, ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
 }
 
-ndk::ScopedAStatus WifiChip::removeNanIfaceInternal(const std::string& ifname) {
+WifiStatus WifiChip::removeNanIfaceInternal(const std::string& ifname) {
     const auto iface = findUsingName(nan_ifaces_, ifname);
     if (!iface.get()) {
         return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
     }
     invalidateAndClear(nan_ifaces_, iface);
     for (const auto& callback : event_cb_handler_.getCallbacks()) {
-        if (!callback->onIfaceRemoved(IfaceType::NAN_IFACE, ifname).isOk()) {
+        if (!callback->onIfaceRemoved(IfaceType::NAN, ifname).isOk()) {
             LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
         }
     }
-    return ndk::ScopedAStatus::ok();
+    return createWifiStatus(WifiStatusCode::SUCCESS);
 }
 
-std::pair<std::shared_ptr<IWifiP2pIface>, ndk::ScopedAStatus> WifiChip::createP2pIfaceInternal() {
+std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::createP2pIfaceInternal() {
     if (!canCurrentModeSupportConcurrencyTypeWithCurrentTypes(IfaceConcurrencyType::P2P)) {
-        return {nullptr, createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE)};
+        return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
     }
     std::string ifname = getPredefinedP2pIfaceName();
-    std::shared_ptr<WifiP2pIface> iface =
-            ndk::SharedRefBase::make<WifiP2pIface>(ifname, legacy_hal_);
+    sp<WifiP2pIface> iface = new WifiP2pIface(ifname, legacy_hal_);
     p2p_ifaces_.push_back(iface);
     for (const auto& callback : event_cb_handler_.getCallbacks()) {
         if (!callback->onIfaceAdded(IfaceType::P2P, ifname).isOk()) {
             LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
         }
     }
-    return {iface, ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
 }
 
-std::pair<std::vector<std::string>, ndk::ScopedAStatus> WifiChip::getP2pIfaceNamesInternal() {
+std::pair<WifiStatus, std::vector<hidl_string>> WifiChip::getP2pIfaceNamesInternal() {
     if (p2p_ifaces_.empty()) {
-        return {std::vector<std::string>(), ndk::ScopedAStatus::ok()};
+        return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
     }
-    return {getNames(p2p_ifaces_), ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(p2p_ifaces_)};
 }
 
-std::pair<std::shared_ptr<IWifiP2pIface>, ndk::ScopedAStatus> WifiChip::getP2pIfaceInternal(
-        const std::string& ifname) {
+std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::getP2pIfaceInternal(const std::string& ifname) {
     const auto iface = findUsingName(p2p_ifaces_, ifname);
     if (!iface.get()) {
-        return {nullptr, createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS)};
+        return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
     }
-    return {iface, ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
 }
 
-ndk::ScopedAStatus WifiChip::removeP2pIfaceInternal(const std::string& ifname) {
+WifiStatus WifiChip::removeP2pIfaceInternal(const std::string& ifname) {
     const auto iface = findUsingName(p2p_ifaces_, ifname);
     if (!iface.get()) {
         return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
@@ -1112,23 +1188,22 @@
             LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
         }
     }
-    return ndk::ScopedAStatus::ok();
+    return createWifiStatus(WifiStatusCode::SUCCESS);
 }
 
-std::pair<std::shared_ptr<IWifiStaIface>, ndk::ScopedAStatus> WifiChip::createStaIfaceInternal() {
+std::pair<WifiStatus, sp<V1_6::IWifiStaIface>> WifiChip::createStaIfaceInternal() {
     if (!canCurrentModeSupportConcurrencyTypeWithCurrentTypes(IfaceConcurrencyType::STA)) {
-        return {nullptr, createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE)};
+        return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
     }
     std::string ifname = allocateStaIfaceName();
     legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->createVirtualInterface(
-            ifname, aidl_struct_util::convertAidlIfaceTypeToLegacy(IfaceType::STA));
+            ifname, hidl_struct_util::convertHidlIfaceTypeToLegacy(IfaceType::STA));
     if (legacy_status != legacy_hal::WIFI_SUCCESS) {
         LOG(ERROR) << "Failed to add interface: " << ifname << " "
                    << legacyErrorToString(legacy_status);
-        return {nullptr, createWifiStatusFromLegacyError(legacy_status)};
+        return {createWifiStatusFromLegacyError(legacy_status), {}};
     }
-    std::shared_ptr<WifiStaIface> iface =
-            ndk::SharedRefBase::make<WifiStaIface>(ifname, legacy_hal_, iface_util_);
+    sp<WifiStaIface> iface = new WifiStaIface(ifname, legacy_hal_, iface_util_);
     sta_ifaces_.push_back(iface);
     for (const auto& callback : event_cb_handler_.getCallbacks()) {
         if (!callback->onIfaceAdded(IfaceType::STA, ifname).isOk()) {
@@ -1136,26 +1211,26 @@
         }
     }
     setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
-    return {iface, ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
 }
 
-std::pair<std::vector<std::string>, ndk::ScopedAStatus> WifiChip::getStaIfaceNamesInternal() {
+std::pair<WifiStatus, std::vector<hidl_string>> WifiChip::getStaIfaceNamesInternal() {
     if (sta_ifaces_.empty()) {
-        return {std::vector<std::string>(), ndk::ScopedAStatus::ok()};
+        return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
     }
-    return {getNames(sta_ifaces_), ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(sta_ifaces_)};
 }
 
-std::pair<std::shared_ptr<IWifiStaIface>, ndk::ScopedAStatus> WifiChip::getStaIfaceInternal(
+std::pair<WifiStatus, sp<V1_6::IWifiStaIface>> WifiChip::getStaIfaceInternal(
         const std::string& ifname) {
     const auto iface = findUsingName(sta_ifaces_, ifname);
     if (!iface.get()) {
-        return {nullptr, createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS)};
+        return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
     }
-    return {iface, ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
 }
 
-ndk::ScopedAStatus WifiChip::removeStaIfaceInternal(const std::string& ifname) {
+WifiStatus WifiChip::removeStaIfaceInternal(const std::string& ifname) {
     const auto iface = findUsingName(sta_ifaces_, ifname);
     if (!iface.get()) {
         return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
@@ -1174,47 +1249,37 @@
         }
     }
     setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
-    return ndk::ScopedAStatus::ok();
+    return createWifiStatus(WifiStatusCode::SUCCESS);
 }
 
-std::pair<std::shared_ptr<IWifiRttController>, ndk::ScopedAStatus>
-WifiChip::createRttControllerInternal(const std::shared_ptr<IWifiStaIface>& bound_iface) {
-    if (sta_ifaces_.size() == 0 &&
-        !canCurrentModeSupportConcurrencyTypeWithCurrentTypes(IfaceConcurrencyType::STA)) {
-        LOG(ERROR) << "createRttControllerInternal: Chip cannot support STAs "
-                      "(and RTT by extension)";
-        return {nullptr, createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE)};
-    }
-    std::shared_ptr<WifiRttController> rtt =
-            WifiRttController::create(getFirstActiveWlanIfaceName(), bound_iface, legacy_hal_);
-    rtt_controllers_.emplace_back(rtt);
-    return {rtt, ndk::ScopedAStatus::ok()};
+std::pair<WifiStatus, sp<V1_0::IWifiRttController>> WifiChip::createRttControllerInternal(
+        const sp<IWifiIface>& /*bound_iface*/) {
+    LOG(ERROR) << "createRttController is not supported on this HAL";
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
 }
 
-std::pair<std::vector<WifiDebugRingBufferStatus>, ndk::ScopedAStatus>
+std::pair<WifiStatus, std::vector<WifiDebugRingBufferStatus>>
 WifiChip::getDebugRingBuffersStatusInternal() {
     legacy_hal::wifi_error legacy_status;
     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(getFirstActiveWlanIfaceName());
     if (legacy_status != legacy_hal::WIFI_SUCCESS) {
-        return {std::vector<WifiDebugRingBufferStatus>(),
-                createWifiStatusFromLegacyError(legacy_status)};
+        return {createWifiStatusFromLegacyError(legacy_status), {}};
     }
-    std::vector<WifiDebugRingBufferStatus> aidl_ring_buffer_status_vec;
-    if (!aidl_struct_util::convertLegacyVectorOfDebugRingBufferStatusToAidl(
-                legacy_ring_buffer_status_vec, &aidl_ring_buffer_status_vec)) {
-        return {std::vector<WifiDebugRingBufferStatus>(),
-                createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
+    std::vector<WifiDebugRingBufferStatus> hidl_ring_buffer_status_vec;
+    if (!hidl_struct_util::convertLegacyVectorOfDebugRingBufferStatusToHidl(
+                legacy_ring_buffer_status_vec, &hidl_ring_buffer_status_vec)) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
     }
-    return {aidl_ring_buffer_status_vec, ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_ring_buffer_status_vec};
 }
 
-ndk::ScopedAStatus WifiChip::startLoggingToDebugRingBufferInternal(
-        const std::string& ring_name, WifiDebugRingBufferVerboseLevel verbose_level,
+WifiStatus WifiChip::startLoggingToDebugRingBufferInternal(
+        const hidl_string& ring_name, WifiDebugRingBufferVerboseLevel verbose_level,
         uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes) {
-    ndk::ScopedAStatus status = registerDebugRingBufferCallback();
-    if (!status.isOk()) {
+    WifiStatus status = registerDebugRingBufferCallback();
+    if (status.code != WifiStatusCode::SUCCESS) {
         return status;
     }
     legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startRingBufferLogging(
@@ -1225,16 +1290,16 @@
             std::pair<std::string, Ringbuffer>(ring_name, Ringbuffer(kMaxBufferSizeBytes)));
     // if verbose logging enabled, turn up HAL daemon logging as well.
     if (verbose_level < WifiDebugRingBufferVerboseLevel::VERBOSE) {
-        ::android::base::SetMinimumLogSeverity(::android::base::DEBUG);
+        android::base::SetMinimumLogSeverity(android::base::DEBUG);
     } else {
-        ::android::base::SetMinimumLogSeverity(::android::base::VERBOSE);
+        android::base::SetMinimumLogSeverity(android::base::VERBOSE);
     }
     return createWifiStatusFromLegacyError(legacy_status);
 }
 
-ndk::ScopedAStatus WifiChip::forceDumpToDebugRingBufferInternal(const std::string& ring_name) {
-    ndk::ScopedAStatus status = registerDebugRingBufferCallback();
-    if (!status.isOk()) {
+WifiStatus WifiChip::forceDumpToDebugRingBufferInternal(const hidl_string& ring_name) {
+    WifiStatus status = registerDebugRingBufferCallback();
+    if (status.code != WifiStatusCode::SUCCESS) {
         return status;
     }
     legacy_hal::wifi_error legacy_status =
@@ -1243,15 +1308,15 @@
     return createWifiStatusFromLegacyError(legacy_status);
 }
 
-ndk::ScopedAStatus WifiChip::flushRingBufferToFileInternal() {
+WifiStatus WifiChip::flushRingBufferToFileInternal() {
     if (!writeRingbufferFilesInternal()) {
         LOG(ERROR) << "Error writing files to flash";
         return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
     }
-    return ndk::ScopedAStatus::ok();
+    return createWifiStatus(WifiStatusCode::SUCCESS);
 }
 
-ndk::ScopedAStatus WifiChip::stopLoggingToDebugRingBufferInternal() {
+WifiStatus WifiChip::stopLoggingToDebugRingBufferInternal() {
     legacy_hal::wifi_error legacy_status =
             legacy_hal_.lock()->deregisterRingBufferCallbackHandler(getFirstActiveWlanIfaceName());
     if (legacy_status == legacy_hal::WIFI_SUCCESS) {
@@ -1260,29 +1325,29 @@
     return createWifiStatusFromLegacyError(legacy_status);
 }
 
-std::pair<WifiDebugHostWakeReasonStats, ndk::ScopedAStatus>
+std::pair<WifiStatus, WifiDebugHostWakeReasonStats>
 WifiChip::getDebugHostWakeReasonStatsInternal() {
     legacy_hal::wifi_error legacy_status;
     legacy_hal::WakeReasonStats legacy_stats;
     std::tie(legacy_status, legacy_stats) =
             legacy_hal_.lock()->getWakeReasonStats(getFirstActiveWlanIfaceName());
     if (legacy_status != legacy_hal::WIFI_SUCCESS) {
-        return {WifiDebugHostWakeReasonStats{}, createWifiStatusFromLegacyError(legacy_status)};
+        return {createWifiStatusFromLegacyError(legacy_status), {}};
     }
-    WifiDebugHostWakeReasonStats aidl_stats;
-    if (!aidl_struct_util::convertLegacyWakeReasonStatsToAidl(legacy_stats, &aidl_stats)) {
-        return {WifiDebugHostWakeReasonStats{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
+    WifiDebugHostWakeReasonStats hidl_stats;
+    if (!hidl_struct_util::convertLegacyWakeReasonStatsToHidl(legacy_stats, &hidl_stats)) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
     }
-    return {aidl_stats, ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_stats};
 }
 
-ndk::ScopedAStatus WifiChip::enableDebugErrorAlertsInternal(bool enable) {
+WifiStatus WifiChip::enableDebugErrorAlertsInternal(bool enable) {
     legacy_hal::wifi_error legacy_status;
     if (enable) {
-        std::weak_ptr<WifiChip> weak_ptr_this = weak_ptr_this_;
+        android::wp<WifiChip> weak_ptr_this(this);
         const auto& on_alert_callback = [weak_ptr_this](int32_t error_code,
                                                         std::vector<uint8_t> debug_data) {
-            const auto shared_ptr_this = weak_ptr_this.lock();
+            const auto shared_ptr_this = weak_ptr_this.promote();
             if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
                 LOG(ERROR) << "Callback invoked on an invalid object";
                 return;
@@ -1302,51 +1367,106 @@
     return createWifiStatusFromLegacyError(legacy_status);
 }
 
-ndk::ScopedAStatus WifiChip::selectTxPowerScenarioInternal(IWifiChip::TxPowerScenario scenario) {
+WifiStatus WifiChip::selectTxPowerScenarioInternal(V1_1::IWifiChip::TxPowerScenario scenario) {
     auto legacy_status = legacy_hal_.lock()->selectTxPowerScenario(
             getFirstActiveWlanIfaceName(),
-            aidl_struct_util::convertAidlTxPowerScenarioToLegacy(scenario));
+            hidl_struct_util::convertHidlTxPowerScenarioToLegacy(scenario));
     return createWifiStatusFromLegacyError(legacy_status);
 }
 
-ndk::ScopedAStatus WifiChip::resetTxPowerScenarioInternal() {
+WifiStatus WifiChip::resetTxPowerScenarioInternal() {
     auto legacy_status = legacy_hal_.lock()->resetTxPowerScenario(getFirstActiveWlanIfaceName());
     return createWifiStatusFromLegacyError(legacy_status);
 }
 
-ndk::ScopedAStatus WifiChip::setLatencyModeInternal(IWifiChip::LatencyMode mode) {
+WifiStatus WifiChip::setLatencyModeInternal(LatencyMode mode) {
     auto legacy_status = legacy_hal_.lock()->setLatencyMode(
-            getFirstActiveWlanIfaceName(), aidl_struct_util::convertAidlLatencyModeToLegacy(mode));
+            getFirstActiveWlanIfaceName(), hidl_struct_util::convertHidlLatencyModeToLegacy(mode));
     return createWifiStatusFromLegacyError(legacy_status);
 }
 
-ndk::ScopedAStatus WifiChip::setMultiStaPrimaryConnectionInternal(const std::string& ifname) {
+WifiStatus WifiChip::registerEventCallbackInternal_1_2(
+        const sp<V1_2::IWifiChipEventCallback>& /* event_callback */) {
+    // Deprecated support for this callback.
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiChip::selectTxPowerScenarioInternal_1_2(TxPowerScenario scenario) {
+    auto legacy_status = legacy_hal_.lock()->selectTxPowerScenario(
+            getFirstActiveWlanIfaceName(),
+            hidl_struct_util::convertHidlTxPowerScenarioToLegacy_1_2(scenario));
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal_1_3() {
+    // Deprecated support for this callback.
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), 0};
+}
+
+std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal_1_5() {
+    legacy_hal::wifi_error legacy_status;
+    uint64_t legacy_feature_set;
+    uint32_t legacy_logger_feature_set;
+    const auto ifname = getFirstActiveWlanIfaceName();
+    std::tie(legacy_status, legacy_feature_set) =
+            legacy_hal_.lock()->getSupportedFeatureSet(ifname);
+    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
+        return {createWifiStatusFromLegacyError(legacy_status), 0};
+    }
+    std::tie(legacy_status, legacy_logger_feature_set) =
+            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;
+    }
+    uint32_t hidl_caps;
+    if (!hidl_struct_util::convertLegacyFeaturesToHidlChipCapabilities(
+                legacy_feature_set, legacy_logger_feature_set, &hidl_caps)) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), 0};
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
+}
+
+std::pair<WifiStatus, sp<V1_4::IWifiRttController>> WifiChip::createRttControllerInternal_1_4(
+        const sp<IWifiIface>& /*bound_iface*/) {
+    LOG(ERROR) << "createRttController_1_4 is not supported on this HAL";
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
+}
+
+WifiStatus WifiChip::registerEventCallbackInternal_1_4(
+        const sp<V1_4::IWifiChipEventCallback>& event_callback) {
+    if (!event_cb_handler_.addCallback(event_callback)) {
+        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+    }
+    return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiChip::setMultiStaPrimaryConnectionInternal(const std::string& ifname) {
     auto legacy_status = legacy_hal_.lock()->multiStaSetPrimaryConnection(ifname);
     return createWifiStatusFromLegacyError(legacy_status);
 }
 
-ndk::ScopedAStatus WifiChip::setMultiStaUseCaseInternal(IWifiChip::MultiStaUseCase use_case) {
+WifiStatus WifiChip::setMultiStaUseCaseInternal(MultiStaUseCase use_case) {
     auto legacy_status = legacy_hal_.lock()->multiStaSetUseCase(
-            aidl_struct_util::convertAidlMultiStaUseCaseToLegacy(use_case));
+            hidl_struct_util::convertHidlMultiStaUseCaseToLegacy(use_case));
     return createWifiStatusFromLegacyError(legacy_status);
 }
 
-ndk::ScopedAStatus WifiChip::setCoexUnsafeChannelsInternal(
-        std::vector<IWifiChip::CoexUnsafeChannel> unsafe_channels, CoexRestriction restrictions) {
+WifiStatus WifiChip::setCoexUnsafeChannelsInternal(std::vector<CoexUnsafeChannel> unsafe_channels,
+                                                   uint32_t restrictions) {
     std::vector<legacy_hal::wifi_coex_unsafe_channel> legacy_unsafe_channels;
-    if (!aidl_struct_util::convertAidlVectorOfCoexUnsafeChannelToLegacy(unsafe_channels,
+    if (!hidl_struct_util::convertHidlVectorOfCoexUnsafeChannelToLegacy(unsafe_channels,
                                                                         &legacy_unsafe_channels)) {
         return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
     }
-    uint32_t aidl_restrictions = static_cast<uint32_t>(restrictions);
     uint32_t legacy_restrictions = 0;
-    if (aidl_restrictions & static_cast<uint32_t>(CoexRestriction::WIFI_DIRECT)) {
+    if (restrictions & CoexRestriction::WIFI_DIRECT) {
         legacy_restrictions |= legacy_hal::wifi_coex_restriction::WIFI_DIRECT;
     }
-    if (aidl_restrictions & static_cast<uint32_t>(CoexRestriction::SOFTAP)) {
+    if (restrictions & CoexRestriction::SOFTAP) {
         legacy_restrictions |= legacy_hal::wifi_coex_restriction::SOFTAP;
     }
-    if (aidl_restrictions & static_cast<uint32_t>(CoexRestriction::WIFI_AWARE)) {
+    if (restrictions & CoexRestriction::WIFI_AWARE) {
         legacy_restrictions |= legacy_hal::wifi_coex_restriction::WIFI_AWARE;
     }
     auto legacy_status =
@@ -1354,34 +1474,57 @@
     return createWifiStatusFromLegacyError(legacy_status);
 }
 
-ndk::ScopedAStatus WifiChip::setCountryCodeInternal(const std::array<uint8_t, 2>& code) {
+WifiStatus WifiChip::setCountryCodeInternal(const std::array<int8_t, 2>& code) {
     auto legacy_status = legacy_hal_.lock()->setCountryCode(getFirstActiveWlanIfaceName(), code);
     return createWifiStatusFromLegacyError(legacy_status);
 }
 
-std::pair<std::vector<WifiUsableChannel>, ndk::ScopedAStatus> WifiChip::getUsableChannelsInternal(
-        WifiBand band, WifiIfaceMode ifaceModeMask, UsableChannelFilter filterMask) {
+std::pair<WifiStatus, std::vector<V1_5::WifiUsableChannel>> WifiChip::getUsableChannelsInternal(
+        WifiBand /*band*/, uint32_t /*ifaceModeMask*/, uint32_t /*filterMask*/) {
+    LOG(ERROR) << "getUsableChannels is not supported on this HAL";
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
+}
+
+WifiStatus WifiChip::triggerSubsystemRestartInternal() {
+    auto legacy_status = legacy_hal_.lock()->triggerSubsystemRestart();
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+std::pair<WifiStatus, sp<V1_6::IWifiRttController>> WifiChip::createRttControllerInternal_1_6(
+        const sp<IWifiIface>& bound_iface) {
+    if (sta_ifaces_.size() == 0 &&
+        !canCurrentModeSupportConcurrencyTypeWithCurrentTypes(IfaceConcurrencyType::STA)) {
+        LOG(ERROR) << "createRttControllerInternal_1_6: Chip cannot support STAs "
+                      "(and RTT by extension)";
+        return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
+    }
+    sp<WifiRttController> rtt =
+            new WifiRttController(getFirstActiveWlanIfaceName(), bound_iface, legacy_hal_);
+    rtt_controllers_.emplace_back(rtt);
+    return {createWifiStatus(WifiStatusCode::SUCCESS), rtt};
+}
+
+std::pair<WifiStatus, std::vector<V1_6::WifiUsableChannel>> WifiChip::getUsableChannelsInternal_1_6(
+        WifiBand band, uint32_t ifaceModeMask, uint32_t filterMask) {
     legacy_hal::wifi_error legacy_status;
     std::vector<legacy_hal::wifi_usable_channel> legacy_usable_channels;
     std::tie(legacy_status, legacy_usable_channels) = legacy_hal_.lock()->getUsableChannels(
-            aidl_struct_util::convertAidlWifiBandToLegacyMacBand(band),
-            aidl_struct_util::convertAidlWifiIfaceModeToLegacy(
-                    static_cast<uint32_t>(ifaceModeMask)),
-            aidl_struct_util::convertAidlUsableChannelFilterToLegacy(
-                    static_cast<uint32_t>(filterMask)));
+            hidl_struct_util::convertHidlWifiBandToLegacyMacBand(band),
+            hidl_struct_util::convertHidlWifiIfaceModeToLegacy(ifaceModeMask),
+            hidl_struct_util::convertHidlUsableChannelFilterToLegacy(filterMask));
 
     if (legacy_status != legacy_hal::WIFI_SUCCESS) {
-        return {std::vector<WifiUsableChannel>(), createWifiStatusFromLegacyError(legacy_status)};
+        return {createWifiStatusFromLegacyError(legacy_status), {}};
     }
-    std::vector<WifiUsableChannel> aidl_usable_channels;
-    if (!aidl_struct_util::convertLegacyWifiUsableChannelsToAidl(legacy_usable_channels,
-                                                                 &aidl_usable_channels)) {
-        return {std::vector<WifiUsableChannel>(), createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
+    std::vector<V1_6::WifiUsableChannel> hidl_usable_channels;
+    if (!hidl_struct_util::convertLegacyWifiUsableChannelsToHidl(legacy_usable_channels,
+                                                                 &hidl_usable_channels)) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
     }
-    return {aidl_usable_channels, ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_usable_channels};
 }
 
-std::pair<WifiRadioCombinationMatrix, ndk::ScopedAStatus>
+std::pair<WifiStatus, V1_6::WifiRadioCombinationMatrix>
 WifiChip::getSupportedRadioCombinationsMatrixInternal() {
     legacy_hal::wifi_error legacy_status;
     legacy_hal::wifi_radio_combination_matrix* legacy_matrix;
@@ -1391,25 +1534,25 @@
     if (legacy_status != legacy_hal::WIFI_SUCCESS) {
         LOG(ERROR) << "Failed to get SupportedRadioCombinations matrix from legacy HAL: "
                    << legacyErrorToString(legacy_status);
-        return {WifiRadioCombinationMatrix{}, createWifiStatusFromLegacyError(legacy_status)};
+        return {createWifiStatusFromLegacyError(legacy_status), {}};
     }
 
-    WifiRadioCombinationMatrix aidl_matrix;
-    if (!aidl_struct_util::convertLegacyRadioCombinationsMatrixToAidl(legacy_matrix,
-                                                                      &aidl_matrix)) {
-        LOG(ERROR) << "Failed convertLegacyRadioCombinationsMatrixToAidl() ";
-        return {WifiRadioCombinationMatrix(), createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS)};
+    V1_6::WifiRadioCombinationMatrix hidl_matrix;
+    if (!hidl_struct_util::convertLegacyRadioCombinationsMatrixToHidl(legacy_matrix,
+                                                                      &hidl_matrix)) {
+        LOG(ERROR) << "Failed convertLegacyRadioCombinationsMatrixToHidl() ";
+        return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), {}};
     }
-    return {aidl_matrix, ndk::ScopedAStatus::ok()};
+    return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_matrix};
 }
 
-ndk::ScopedAStatus WifiChip::triggerSubsystemRestartInternal() {
-    auto legacy_status = legacy_hal_.lock()->triggerSubsystemRestart();
-    return createWifiStatusFromLegacyError(legacy_status);
+std::pair<WifiStatus, std::vector<V1_6::IWifiChip::ChipMode>>
+WifiChip::getAvailableModesInternal_1_6() {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), modes_};
 }
 
-ndk::ScopedAStatus WifiChip::handleChipConfiguration(
-        /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock, int32_t mode_id) {
+WifiStatus WifiChip::handleChipConfiguration(
+        /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock, ChipModeId mode_id) {
     // If the chip is already configured in a different mode, stop
     // the legacy HAL and then start it after firmware mode change.
     if (isValidModeId(current_mode_id_)) {
@@ -1438,41 +1581,41 @@
     }
     // Every time the HAL is restarted, we need to register the
     // radio mode change callback.
-    ndk::ScopedAStatus status = registerRadioModeChangeCallback();
-    if (!status.isOk()) {
-        // This is probably not a critical failure?
+    WifiStatus status = registerRadioModeChangeCallback();
+    if (status.code != WifiStatusCode::SUCCESS) {
+        // This probably is not a critical failure?
         LOG(ERROR) << "Failed to register radio mode change callback";
     }
     // Extract and save the version information into property.
-    std::pair<IWifiChip::ChipDebugInfo, ndk::ScopedAStatus> version_info;
+    std::pair<WifiStatus, V1_4::IWifiChip::ChipDebugInfo> version_info;
     version_info = WifiChip::requestChipDebugInfoInternal();
-    if (version_info.second.isOk()) {
+    if (WifiStatusCode::SUCCESS == version_info.first.code) {
         property_set("vendor.wlan.firmware.version",
-                     version_info.first.firmwareDescription.c_str());
-        property_set("vendor.wlan.driver.version", version_info.first.driverDescription.c_str());
+                     version_info.second.firmwareDescription.c_str());
+        property_set("vendor.wlan.driver.version", version_info.second.driverDescription.c_str());
     }
 
-    return ndk::ScopedAStatus::ok();
+    return createWifiStatus(WifiStatusCode::SUCCESS);
 }
 
-ndk::ScopedAStatus WifiChip::registerDebugRingBufferCallback() {
+WifiStatus WifiChip::registerDebugRingBufferCallback() {
     if (debug_ring_buffer_cb_registered_) {
-        return ndk::ScopedAStatus::ok();
+        return createWifiStatus(WifiStatusCode::SUCCESS);
     }
 
-    std::weak_ptr<WifiChip> weak_ptr_this = weak_ptr_this_;
+    android::wp<WifiChip> weak_ptr_this(this);
     const auto& on_ring_buffer_data_callback =
             [weak_ptr_this](const std::string& name, const std::vector<uint8_t>& data,
                             const legacy_hal::wifi_ring_buffer_status& status) {
-                const auto shared_ptr_this = weak_ptr_this.lock();
+                const auto shared_ptr_this = weak_ptr_this.promote();
                 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
                     LOG(ERROR) << "Callback invoked on an invalid object";
                     return;
                 }
-                WifiDebugRingBufferStatus aidl_status;
+                WifiDebugRingBufferStatus hidl_status;
                 Ringbuffer::AppendStatus appendstatus;
-                if (!aidl_struct_util::convertLegacyDebugRingBufferStatusToAidl(status,
-                                                                                &aidl_status)) {
+                if (!hidl_struct_util::convertLegacyDebugRingBufferStatusToHidl(status,
+                                                                                &hidl_status)) {
                     LOG(ERROR) << "Error converting ring buffer status";
                     return;
                 }
@@ -1493,6 +1636,7 @@
                     shared_ptr_this->writeRingbufferFilesInternal();
                     return;
                 }
+
             };
     legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->registerRingBufferCallbackHandler(
             getFirstActiveWlanIfaceName(), on_ring_buffer_data_callback);
@@ -1503,24 +1647,25 @@
     return createWifiStatusFromLegacyError(legacy_status);
 }
 
-ndk::ScopedAStatus WifiChip::registerRadioModeChangeCallback() {
-    std::weak_ptr<WifiChip> weak_ptr_this = weak_ptr_this_;
+WifiStatus WifiChip::registerRadioModeChangeCallback() {
+    android::wp<WifiChip> weak_ptr_this(this);
     const auto& on_radio_mode_change_callback =
             [weak_ptr_this](const std::vector<legacy_hal::WifiMacInfo>& mac_infos) {
-                const auto shared_ptr_this = weak_ptr_this.lock();
+                const auto shared_ptr_this = weak_ptr_this.promote();
                 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
                     LOG(ERROR) << "Callback invoked on an invalid object";
                     return;
                 }
-                std::vector<IWifiChipEventCallback::RadioModeInfo> aidl_radio_mode_infos;
-                if (!aidl_struct_util::convertLegacyWifiMacInfosToAidl(mac_infos,
-                                                                       &aidl_radio_mode_infos)) {
+                std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo> hidl_radio_mode_infos;
+                if (!hidl_struct_util::convertLegacyWifiMacInfosToHidl(mac_infos,
+                                                                       &hidl_radio_mode_infos)) {
                     LOG(ERROR) << "Error converting wifi mac info";
                     return;
                 }
                 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->onRadioModeChange(aidl_radio_mode_infos).isOk()) {
-                        LOG(ERROR) << "Failed to invoke onRadioModeChange callback";
+                    if (!callback->onRadioModeChange_1_4(hidl_radio_mode_infos).isOk()) {
+                        LOG(ERROR) << "Failed to invoke onRadioModeChange_1_4"
+                                   << " callback on: " << toString(callback);
                     }
                 }
             };
@@ -1530,11 +1675,11 @@
     return createWifiStatusFromLegacyError(legacy_status);
 }
 
-std::vector<IWifiChip::ChipConcurrencyCombination>
+std::vector<V1_6::IWifiChip::ChipConcurrencyCombination>
 WifiChip::getCurrentModeConcurrencyCombinations() {
     if (!isValidModeId(current_mode_id_)) {
         LOG(ERROR) << "Chip not configured in a mode yet";
-        return std::vector<IWifiChip::ChipConcurrencyCombination>();
+        return {};
     }
     for (const auto& mode : modes_) {
         if (mode.id == current_mode_id_) {
@@ -1542,7 +1687,7 @@
         }
     }
     CHECK(0) << "Expected to find concurrency combinations for current mode!";
-    return std::vector<IWifiChip::ChipConcurrencyCombination>();
+    return {};
 }
 
 // Returns a map indexed by IfaceConcurrencyType with the number of ifaces currently
@@ -1562,7 +1707,7 @@
     }
     iface_counts[IfaceConcurrencyType::AP] = num_ap;
     iface_counts[IfaceConcurrencyType::AP_BRIDGED] = num_ap_bridged;
-    iface_counts[IfaceConcurrencyType::NAN_IFACE] = nan_ifaces_.size();
+    iface_counts[IfaceConcurrencyType::NAN] = nan_ifaces_.size();
     iface_counts[IfaceConcurrencyType::P2P] = p2p_ifaces_.size();
     iface_counts[IfaceConcurrencyType::STA] = sta_ifaces_.size();
     return iface_counts;
@@ -1573,10 +1718,10 @@
 // of each concurrency type in the combination.
 // This method is a port of HalDeviceManager.expandConcurrencyCombos() from framework.
 std::vector<std::map<IfaceConcurrencyType, size_t>> WifiChip::expandConcurrencyCombinations(
-        const IWifiChip::ChipConcurrencyCombination& combination) {
-    int32_t num_expanded_combos = 1;
+        const V1_6::IWifiChip::ChipConcurrencyCombination& combination) {
+    uint32_t num_expanded_combos = 1;
     for (const auto& limit : combination.limits) {
-        for (int32_t i = 0; i < limit.maxIfaces; i++) {
+        for (uint32_t i = 0; i < limit.maxIfaces; i++) {
             num_expanded_combos *= limit.types.size();
         }
     }
@@ -1586,17 +1731,17 @@
     std::vector<std::map<IfaceConcurrencyType, size_t>> expanded_combos;
     expanded_combos.resize(num_expanded_combos);
     for (auto& expanded_combo : expanded_combos) {
-        for (const auto type : {IfaceConcurrencyType::AP, IfaceConcurrencyType::AP_BRIDGED,
-                                IfaceConcurrencyType::NAN_IFACE, IfaceConcurrencyType::P2P,
-                                IfaceConcurrencyType::STA}) {
+        for (const auto type :
+             {IfaceConcurrencyType::AP, IfaceConcurrencyType::AP_BRIDGED, IfaceConcurrencyType::NAN,
+              IfaceConcurrencyType::P2P, IfaceConcurrencyType::STA}) {
             expanded_combo[type] = 0;
         }
     }
-    int32_t span = num_expanded_combos;
+    uint32_t span = num_expanded_combos;
     for (const auto& limit : combination.limits) {
-        for (int32_t i = 0; i < limit.maxIfaces; i++) {
+        for (uint32_t i = 0; i < limit.maxIfaces; i++) {
             span /= limit.types.size();
-            for (int32_t k = 0; k < num_expanded_combos; ++k) {
+            for (uint32_t k = 0; k < num_expanded_combos; ++k) {
                 const auto iface_type = limit.types[(k / span) % limit.types.size()];
                 expanded_combos[k][iface_type]++;
             }
@@ -1612,8 +1757,8 @@
 
     // Check if we have space for 1 more iface of |type| in this combo
     for (const auto type :
-         {IfaceConcurrencyType::AP, IfaceConcurrencyType::AP_BRIDGED,
-          IfaceConcurrencyType::NAN_IFACE, IfaceConcurrencyType::P2P, IfaceConcurrencyType::STA}) {
+         {IfaceConcurrencyType::AP, IfaceConcurrencyType::AP_BRIDGED, IfaceConcurrencyType::NAN,
+          IfaceConcurrencyType::P2P, IfaceConcurrencyType::STA}) {
         size_t num_ifaces_needed = current_combo.at(type);
         if (type == requested_type) {
             num_ifaces_needed++;
@@ -1657,8 +1802,8 @@
         const std::map<IfaceConcurrencyType, size_t>& req_combo) {
     // Check if we have space for 1 more |type| in this combo
     for (const auto type :
-         {IfaceConcurrencyType::AP, IfaceConcurrencyType::AP_BRIDGED,
-          IfaceConcurrencyType::NAN_IFACE, IfaceConcurrencyType::P2P, IfaceConcurrencyType::STA}) {
+         {IfaceConcurrencyType::AP, IfaceConcurrencyType::AP_BRIDGED, IfaceConcurrencyType::NAN,
+          IfaceConcurrencyType::P2P, IfaceConcurrencyType::STA}) {
         if (req_combo.count(type) == 0) {
             // Concurrency type not in the req_combo.
             continue;
@@ -1671,7 +1816,6 @@
     }
     return true;
 }
-
 // This method does the following:
 // a) Enumerate all possible concurrency combos by expanding the current
 //    ChipConcurrencyCombination.
@@ -1707,7 +1851,7 @@
     return canCurrentModeSupportConcurrencyCombo(req_iface_combo);
 }
 
-bool WifiChip::isValidModeId(int32_t mode_id) {
+bool WifiChip::isValidModeId(ChipModeId mode_id) {
     for (const auto& mode : modes_) {
         if (mode.id == mode_id) {
             return true;
@@ -1873,21 +2017,28 @@
     br_ifaces_ap_instances_.clear();
 }
 
-void WifiChip::invalidateAndClearBridgedAp(const std::string& br_name) {
-    if (br_name.empty()) return;
-    // delete managed interfaces
+void WifiChip::deleteApIface(const std::string& if_name) {
+    if (if_name.empty()) return;
+    // delete bridged interfaces if have
     for (auto const& it : br_ifaces_ap_instances_) {
-        if (it.first == br_name) {
+        if (it.first == if_name) {
             for (auto const& iface : it.second) {
-                iface_util_->removeIfaceFromBridge(br_name, iface);
+                iface_util_->removeIfaceFromBridge(if_name, iface);
                 legacy_hal_.lock()->deleteVirtualInterface(iface);
             }
-            iface_util_->deleteBridge(br_name);
-            br_ifaces_ap_instances_.erase(br_name);
-            break;
+            iface_util_->deleteBridge(if_name);
+            br_ifaces_ap_instances_.erase(if_name);
+            // ifname is bridged AP, return here.
+            return;
         }
     }
-    return;
+
+    // No bridged AP case, delete AP iface
+    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->deleteVirtualInterface(if_name);
+    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
+        LOG(ERROR) << "Failed to remove interface: " << if_name << " "
+                   << legacyErrorToString(legacy_status);
+    }
 }
 
 bool WifiChip::findUsingNameFromBridgedApInstances(const std::string& name) {
@@ -1904,7 +2055,8 @@
     return false;
 }
 
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/1.6/default/wifi_chip.h b/wifi/1.6/default/wifi_chip.h
new file mode 100644
index 0000000..e8ddaa6
--- /dev/null
+++ b/wifi/1.6/default/wifi_chip.h
@@ -0,0 +1,317 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WIFI_CHIP_H_
+#define WIFI_CHIP_H_
+
+// HACK: NAN is a macro defined in math.h, which can be included in various
+// headers. This wifi HAL uses an enum called NAN, which does not compile when
+// the macro is defined. Undefine NAN to work around it.
+#undef NAN
+
+#include <list>
+#include <map>
+#include <mutex>
+
+#include <android-base/macros.h>
+#include <android/hardware/wifi/1.6/IWifiChip.h>
+#include <android/hardware/wifi/1.6/IWifiRttController.h>
+#include <android/hardware/wifi/1.6/IWifiStaIface.h>
+
+#include "hidl_callback_util.h"
+#include "ringbuffer.h"
+#include "wifi_ap_iface.h"
+#include "wifi_feature_flags.h"
+#include "wifi_legacy_hal.h"
+#include "wifi_mode_controller.h"
+#include "wifi_nan_iface.h"
+#include "wifi_p2p_iface.h"
+#include "wifi_rtt_controller.h"
+#include "wifi_sta_iface.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+using namespace android::hardware::wifi::V1_0;
+using V1_5::WifiBand;
+
+/**
+ * HIDL interface object used to control a Wifi HAL chip instance.
+ * Since there is only a single chip instance used today, there is no
+ * identifying handle information stored here.
+ */
+class WifiChip : public V1_6::IWifiChip {
+  public:
+    WifiChip(ChipId chip_id, bool is_primary,
+             const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
+             const std::weak_ptr<mode_controller::WifiModeController> mode_controller,
+             const std::shared_ptr<iface_util::WifiIfaceUtil> iface_util,
+             const std::weak_ptr<feature_flags::WifiFeatureFlags> feature_flags,
+             const std::function<void(const std::string&)>& subsystemCallbackHandler);
+    // HIDL does not provide a built-in mechanism to let the server invalidate
+    // a HIDL interface object after creation. If any client process holds onto
+    // a reference to the object in their context, any method calls on that
+    // reference will continue to be directed to the server.
+    //
+    // However Wifi HAL needs to control the lifetime of these objects. So, add
+    // a public |invalidate| method to |WifiChip| and it's child objects. This
+    // will be used to mark an object invalid when either:
+    // a) Wifi HAL is stopped, or
+    // b) Wifi Chip is reconfigured.
+    //
+    // All HIDL method implementations should check if the object is still
+    // marked valid before processing them.
+    void invalidate();
+    bool isValid();
+    std::set<sp<V1_4::IWifiChipEventCallback>> getEventCallbacks();
+
+    // HIDL methods exposed.
+    Return<void> getId(getId_cb hidl_status_cb) override;
+    // Deprecated support for this callback
+    Return<void> registerEventCallback(const sp<V1_0::IWifiChipEventCallback>& event_callback,
+                                       registerEventCallback_cb hidl_status_cb) override;
+    Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override;
+    Return<void> getAvailableModes(getAvailableModes_cb hidl_status_cb) override;
+    Return<void> configureChip(ChipModeId mode_id, configureChip_cb hidl_status_cb) override;
+    Return<void> getMode(getMode_cb hidl_status_cb) override;
+    Return<void> requestChipDebugInfo(requestChipDebugInfo_cb hidl_status_cb) override;
+    Return<void> requestDriverDebugDump(requestDriverDebugDump_cb hidl_status_cb) override;
+    Return<void> requestFirmwareDebugDump(requestFirmwareDebugDump_cb hidl_status_cb) override;
+    Return<void> createApIface(createApIface_cb hidl_status_cb) override;
+    Return<void> createBridgedApIface(createBridgedApIface_cb hidl_status_cb) override;
+    Return<void> getApIfaceNames(getApIfaceNames_cb hidl_status_cb) override;
+    Return<void> getApIface(const hidl_string& ifname, getApIface_cb hidl_status_cb) override;
+    Return<void> removeApIface(const hidl_string& ifname, removeApIface_cb hidl_status_cb) override;
+    Return<void> removeIfaceInstanceFromBridgedApIface(
+            const hidl_string& brIfaceName, const hidl_string& ifaceInstanceName,
+            removeIfaceInstanceFromBridgedApIface_cb hidl_status_cb) override;
+    Return<void> createNanIface(createNanIface_cb hidl_status_cb) override;
+    Return<void> getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) override;
+    Return<void> getNanIface(const hidl_string& ifname, getNanIface_cb hidl_status_cb) override;
+    Return<void> removeNanIface(const hidl_string& ifname,
+                                removeNanIface_cb hidl_status_cb) override;
+    Return<void> createP2pIface(createP2pIface_cb hidl_status_cb) override;
+    Return<void> getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) override;
+    Return<void> getP2pIface(const hidl_string& ifname, getP2pIface_cb hidl_status_cb) override;
+    Return<void> removeP2pIface(const hidl_string& ifname,
+                                removeP2pIface_cb hidl_status_cb) override;
+    Return<void> createStaIface(createStaIface_cb hidl_status_cb) override;
+    Return<void> getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) override;
+    Return<void> getStaIface(const hidl_string& ifname, getStaIface_cb hidl_status_cb) override;
+    Return<void> removeStaIface(const hidl_string& ifname,
+                                removeStaIface_cb hidl_status_cb) override;
+    Return<void> createRttController(const sp<IWifiIface>& bound_iface,
+                                     createRttController_cb hidl_status_cb) override;
+    Return<void> getDebugRingBuffersStatus(getDebugRingBuffersStatus_cb hidl_status_cb) override;
+    Return<void> startLoggingToDebugRingBuffer(
+            const hidl_string& ring_name, WifiDebugRingBufferVerboseLevel verbose_level,
+            uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes,
+            startLoggingToDebugRingBuffer_cb hidl_status_cb) override;
+    Return<void> forceDumpToDebugRingBuffer(const hidl_string& ring_name,
+                                            forceDumpToDebugRingBuffer_cb hidl_status_cb) override;
+    Return<void> flushRingBufferToFile(flushRingBufferToFile_cb hidl_status_cb) override;
+    Return<void> stopLoggingToDebugRingBuffer(
+            stopLoggingToDebugRingBuffer_cb hidl_status_cb) override;
+    Return<void> getDebugHostWakeReasonStats(
+            getDebugHostWakeReasonStats_cb hidl_status_cb) override;
+    Return<void> enableDebugErrorAlerts(bool enable,
+                                        enableDebugErrorAlerts_cb hidl_status_cb) override;
+    Return<void> selectTxPowerScenario(V1_1::IWifiChip::TxPowerScenario scenario,
+                                       selectTxPowerScenario_cb hidl_status_cb) override;
+    Return<void> resetTxPowerScenario(resetTxPowerScenario_cb hidl_status_cb) override;
+    Return<void> setLatencyMode(LatencyMode mode, setLatencyMode_cb hidl_status_cb) override;
+    Return<void> registerEventCallback_1_2(const sp<V1_2::IWifiChipEventCallback>& event_callback,
+                                           registerEventCallback_1_2_cb hidl_status_cb) override;
+    Return<void> selectTxPowerScenario_1_2(TxPowerScenario scenario,
+                                           selectTxPowerScenario_cb hidl_status_cb) override;
+    Return<void> getCapabilities_1_3(getCapabilities_cb hidl_status_cb) override;
+    Return<void> getCapabilities_1_5(getCapabilities_1_5_cb hidl_status_cb) override;
+    Return<void> debug(const hidl_handle& handle, const hidl_vec<hidl_string>& options) override;
+    Return<void> createRttController_1_4(const sp<IWifiIface>& bound_iface,
+                                         createRttController_1_4_cb hidl_status_cb) override;
+    Return<void> registerEventCallback_1_4(const sp<V1_4::IWifiChipEventCallback>& event_callback,
+                                           registerEventCallback_1_4_cb hidl_status_cb) override;
+    Return<void> setMultiStaPrimaryConnection(
+            const hidl_string& ifname, setMultiStaPrimaryConnection_cb hidl_status_cb) override;
+    Return<void> setMultiStaUseCase(MultiStaUseCase use_case,
+                                    setMultiStaUseCase_cb hidl_status_cb) override;
+    Return<void> setCoexUnsafeChannels(const hidl_vec<CoexUnsafeChannel>& unsafe_channels,
+                                       hidl_bitfield<IfaceType> restrictions,
+                                       setCoexUnsafeChannels_cb hidl_status_cb) override;
+    Return<void> setCountryCode(const hidl_array<int8_t, 2>& code,
+                                setCountryCode_cb _hidl_cb) override;
+    Return<void> getUsableChannels(WifiBand band, hidl_bitfield<V1_5::WifiIfaceMode> ifaceModeMask,
+                                   hidl_bitfield<V1_5::IWifiChip::UsableChannelFilter> filterMask,
+                                   getUsableChannels_cb _hidl_cb) override;
+    Return<void> triggerSubsystemRestart(triggerSubsystemRestart_cb hidl_status_cb) override;
+    Return<void> createRttController_1_6(const sp<IWifiIface>& bound_iface,
+                                         createRttController_1_6_cb hidl_status_cb) override;
+    Return<void> getUsableChannels_1_6(WifiBand band,
+                                       hidl_bitfield<V1_5::WifiIfaceMode> ifaceModeMask,
+                                       hidl_bitfield<UsableChannelFilter> filterMask,
+                                       getUsableChannels_1_6_cb _hidl_cb) override;
+    Return<void> getSupportedRadioCombinationsMatrix(
+            getSupportedRadioCombinationsMatrix_cb hidl_status_cb) override;
+    Return<void> getAvailableModes_1_6(getAvailableModes_1_6_cb hidl_status_cb) override;
+
+  private:
+    void invalidateAndRemoveAllIfaces();
+    // When a STA iface is removed any dependent NAN-ifaces/RTT-controllers are
+    // invalidated & removed.
+    void invalidateAndRemoveDependencies(const std::string& removed_iface_name);
+
+    // Corresponding worker functions for the HIDL methods.
+    std::pair<WifiStatus, ChipId> getIdInternal();
+    // Deprecated support for this callback
+    WifiStatus registerEventCallbackInternal(
+            const sp<V1_0::IWifiChipEventCallback>& event_callback);
+    std::pair<WifiStatus, uint32_t> getCapabilitiesInternal();
+    std::pair<WifiStatus, std::vector<V1_0::IWifiChip::ChipMode>> getAvailableModesInternal();
+    WifiStatus configureChipInternal(std::unique_lock<std::recursive_mutex>* lock,
+                                     ChipModeId mode_id);
+    std::pair<WifiStatus, uint32_t> getModeInternal();
+    std::pair<WifiStatus, IWifiChip::ChipDebugInfo> requestChipDebugInfoInternal();
+    std::pair<WifiStatus, std::vector<uint8_t>> requestDriverDebugDumpInternal();
+    std::pair<WifiStatus, std::vector<uint8_t>> requestFirmwareDebugDumpInternal();
+    sp<WifiApIface> newWifiApIface(std::string& ifname);
+    WifiStatus createVirtualApInterface(const std::string& apVirtIf);
+    std::pair<WifiStatus, sp<V1_5::IWifiApIface>> createApIfaceInternal();
+    std::pair<WifiStatus, sp<V1_5::IWifiApIface>> createBridgedApIfaceInternal();
+    std::pair<WifiStatus, std::vector<hidl_string>> getApIfaceNamesInternal();
+    std::pair<WifiStatus, sp<V1_5::IWifiApIface>> getApIfaceInternal(const std::string& ifname);
+    WifiStatus removeApIfaceInternal(const std::string& ifname);
+    WifiStatus removeIfaceInstanceFromBridgedApIfaceInternal(const std::string& brIfaceName,
+                                                             const std::string& ifInstanceName);
+    std::pair<WifiStatus, sp<V1_4::IWifiNanIface>> createNanIfaceInternal();
+    std::pair<WifiStatus, std::vector<hidl_string>> getNanIfaceNamesInternal();
+    std::pair<WifiStatus, sp<V1_4::IWifiNanIface>> getNanIfaceInternal(const std::string& ifname);
+    WifiStatus removeNanIfaceInternal(const std::string& ifname);
+    std::pair<WifiStatus, sp<IWifiP2pIface>> createP2pIfaceInternal();
+    std::pair<WifiStatus, std::vector<hidl_string>> getP2pIfaceNamesInternal();
+    std::pair<WifiStatus, sp<IWifiP2pIface>> getP2pIfaceInternal(const std::string& ifname);
+    WifiStatus removeP2pIfaceInternal(const std::string& ifname);
+    std::pair<WifiStatus, sp<V1_6::IWifiStaIface>> createStaIfaceInternal();
+    std::pair<WifiStatus, std::vector<hidl_string>> getStaIfaceNamesInternal();
+    std::pair<WifiStatus, sp<V1_6::IWifiStaIface>> getStaIfaceInternal(const std::string& ifname);
+    WifiStatus removeStaIfaceInternal(const std::string& ifname);
+    std::pair<WifiStatus, sp<V1_0::IWifiRttController>> createRttControllerInternal(
+            const sp<IWifiIface>& bound_iface);
+    std::pair<WifiStatus, std::vector<WifiDebugRingBufferStatus>>
+    getDebugRingBuffersStatusInternal();
+    WifiStatus startLoggingToDebugRingBufferInternal(const hidl_string& ring_name,
+                                                     WifiDebugRingBufferVerboseLevel verbose_level,
+                                                     uint32_t max_interval_in_sec,
+                                                     uint32_t min_data_size_in_bytes);
+    WifiStatus forceDumpToDebugRingBufferInternal(const hidl_string& ring_name);
+    WifiStatus flushRingBufferToFileInternal();
+    WifiStatus stopLoggingToDebugRingBufferInternal();
+    std::pair<WifiStatus, WifiDebugHostWakeReasonStats> getDebugHostWakeReasonStatsInternal();
+    WifiStatus enableDebugErrorAlertsInternal(bool enable);
+    WifiStatus selectTxPowerScenarioInternal(V1_1::IWifiChip::TxPowerScenario scenario);
+    WifiStatus resetTxPowerScenarioInternal();
+    WifiStatus setLatencyModeInternal(LatencyMode mode);
+    WifiStatus registerEventCallbackInternal_1_2(
+            const sp<V1_2::IWifiChipEventCallback>& event_callback);
+    WifiStatus selectTxPowerScenarioInternal_1_2(TxPowerScenario scenario);
+    std::pair<WifiStatus, uint32_t> getCapabilitiesInternal_1_3();
+    std::pair<WifiStatus, uint32_t> getCapabilitiesInternal_1_5();
+    std::pair<WifiStatus, sp<V1_4::IWifiRttController>> createRttControllerInternal_1_4(
+            const sp<IWifiIface>& bound_iface);
+    WifiStatus registerEventCallbackInternal_1_4(
+            const sp<V1_4::IWifiChipEventCallback>& event_callback);
+    WifiStatus setMultiStaPrimaryConnectionInternal(const std::string& ifname);
+    WifiStatus setMultiStaUseCaseInternal(MultiStaUseCase use_case);
+    WifiStatus setCoexUnsafeChannelsInternal(std::vector<CoexUnsafeChannel> unsafe_channels,
+                                             uint32_t restrictions);
+    WifiStatus setCountryCodeInternal(const std::array<int8_t, 2>& code);
+    std::pair<WifiStatus, std::vector<V1_5::WifiUsableChannel>> getUsableChannelsInternal(
+            WifiBand band, uint32_t ifaceModeMask, uint32_t filterMask);
+    WifiStatus handleChipConfiguration(std::unique_lock<std::recursive_mutex>* lock,
+                                       ChipModeId mode_id);
+    WifiStatus registerDebugRingBufferCallback();
+    WifiStatus registerRadioModeChangeCallback();
+    std::vector<V1_6::IWifiChip::ChipConcurrencyCombination>
+    getCurrentModeConcurrencyCombinations();
+    std::map<IfaceConcurrencyType, size_t> getCurrentConcurrencyCombination();
+    std::vector<std::map<IfaceConcurrencyType, size_t>> expandConcurrencyCombinations(
+            const V1_6::IWifiChip::ChipConcurrencyCombination& combination);
+    bool canExpandedConcurrencyComboSupportConcurrencyTypeWithCurrentTypes(
+            const std::map<IfaceConcurrencyType, size_t>& expanded_combo,
+            IfaceConcurrencyType requested_type);
+    bool canCurrentModeSupportConcurrencyTypeWithCurrentTypes(IfaceConcurrencyType requested_type);
+    bool canExpandedConcurrencyComboSupportConcurrencyCombo(
+            const std::map<IfaceConcurrencyType, size_t>& expanded_combo,
+            const std::map<IfaceConcurrencyType, size_t>& req_combo);
+    bool canCurrentModeSupportConcurrencyCombo(
+            const std::map<IfaceConcurrencyType, size_t>& req_combo);
+    bool canCurrentModeSupportConcurrencyType(IfaceConcurrencyType requested_type);
+    bool isValidModeId(ChipModeId mode_id);
+    bool isStaApConcurrencyAllowedInCurrentMode();
+    bool isDualStaConcurrencyAllowedInCurrentMode();
+    uint32_t startIdxOfApIface();
+    std::string getFirstActiveWlanIfaceName();
+    std::string allocateApOrStaIfaceName(IfaceType type, uint32_t start_idx);
+    std::string allocateApIfaceName();
+    std::vector<std::string> allocateBridgedApInstanceNames();
+    std::string allocateStaIfaceName();
+    bool writeRingbufferFilesInternal();
+    std::string getWlanIfaceNameWithType(IfaceType type, unsigned idx);
+    void invalidateAndClearBridgedApAll();
+    void deleteApIface(const std::string& if_name);
+    bool findUsingNameFromBridgedApInstances(const std::string& name);
+    WifiStatus triggerSubsystemRestartInternal();
+    std::pair<WifiStatus, sp<V1_6::IWifiRttController>> createRttControllerInternal_1_6(
+            const sp<IWifiIface>& bound_iface);
+    std::pair<WifiStatus, std::vector<V1_6::WifiUsableChannel>> getUsableChannelsInternal_1_6(
+            WifiBand band, uint32_t ifaceModeMask, uint32_t filterMask);
+    std::pair<WifiStatus, WifiRadioCombinationMatrix> getSupportedRadioCombinationsMatrixInternal();
+    std::pair<WifiStatus, std::vector<V1_6::IWifiChip::ChipMode>> getAvailableModesInternal_1_6();
+
+    ChipId chip_id_;
+    std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
+    std::weak_ptr<mode_controller::WifiModeController> mode_controller_;
+    std::shared_ptr<iface_util::WifiIfaceUtil> iface_util_;
+    std::vector<sp<WifiApIface>> ap_ifaces_;
+    std::vector<sp<WifiNanIface>> nan_ifaces_;
+    std::vector<sp<WifiP2pIface>> p2p_ifaces_;
+    std::vector<sp<WifiStaIface>> sta_ifaces_;
+    std::vector<sp<WifiRttController>> rtt_controllers_;
+    std::map<std::string, Ringbuffer> ringbuffer_map_;
+    bool is_valid_;
+    // Members pertaining to chip configuration.
+    uint32_t current_mode_id_;
+    std::mutex lock_t;
+    std::vector<V1_6::IWifiChip::ChipMode> modes_;
+    // The legacy ring buffer callback API has only a global callback
+    // registration mechanism. Use this to check if we have already
+    // registered a callback.
+    bool debug_ring_buffer_cb_registered_;
+    hidl_callback_util::HidlCallbackHandler<V1_4::IWifiChipEventCallback> event_cb_handler_;
+
+    const std::function<void(const std::string&)> subsystemCallbackHandler_;
+    std::map<std::string, std::vector<std::string>> br_ifaces_ap_instances_;
+    DISALLOW_COPY_AND_ASSIGN(WifiChip);
+};
+
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
+
+#endif  // WIFI_CHIP_H_
diff --git a/wifi/1.6/default/wifi_feature_flags.cpp b/wifi/1.6/default/wifi_feature_flags.cpp
new file mode 100644
index 0000000..e80a3cd
--- /dev/null
+++ b/wifi/1.6/default/wifi_feature_flags.cpp
@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string>
+
+#include <android-base/logging.h>
+#include <cutils/properties.h>
+
+#include "wifi_feature_flags.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+namespace feature_flags {
+
+using V1_0::ChipModeId;
+using V1_0::IWifiChip;
+using V1_6::IfaceConcurrencyType;
+
+/* The chip may either have a single mode supporting any number of combinations,
+ * or a fixed dual-mode (so it involves firmware loading to switch between
+ * modes) setting. If there is a need to support more modes, it needs to be
+ * implemented manually in WiFi HAL (see changeFirmwareMode in
+ * WifiChip::handleChipConfiguration).
+ *
+ * Supported combinations are defined in device's makefile, for example:
+ *    WIFI_HAL_INTERFACE_COMBINATIONS := {{{STA, AP}, 1}, {{P2P, NAN}, 1}},
+ *    WIFI_HAL_INTERFACE_COMBINATIONS += {{{STA}, 1}, {{AP}, 2}}
+ * What means:
+ *    Interface concurrency combination 1: 1 STA or AP and 1 P2P or NAN concurrent iface
+ *                             operations.
+ *    Interface concurrency combination 2: 1 STA and 2 AP concurrent iface operations.
+ *
+ * For backward compatibility, the following makefile flags can be used to
+ * generate combinations list:
+ *  - WIFI_HIDL_FEATURE_DUAL_INTERFACE
+ *  - WIFI_HIDL_FEATURE_DISABLE_AP
+ *  - WIFI_HIDL_FEATURE_AWARE
+ * However, they are ignored if WIFI_HAL_INTERFACE_COMBINATIONS was provided.
+ * With WIFI_HIDL_FEATURE_DUAL_INTERFACE flag set, there is a single mode with
+ * two concurrency combinations:
+ *    Interface Concurrency Combination 1: Will support 1 STA and 1 P2P or NAN (optional)
+ *                             concurrent iface operations.
+ *    Interface Concurrency Combination 2: Will support 1 STA and 1 AP concurrent
+ *                             iface operations.
+ *
+ * The only dual-mode configuration supported is for alternating STA and AP
+ * mode, that may involve firmware reloading. In such case, there are 2 separate
+ * modes of operation with 1 concurrency combination each:
+ *    Mode 1 (STA mode): Will support 1 STA and 1 P2P or NAN (optional)
+ *                       concurrent iface operations.
+ *    Mode 2 (AP mode): Will support 1 AP iface operation.
+ *
+ * If Aware is enabled, the concurrency combination will be modified to support either
+ * P2P or NAN in place of just P2P.
+ */
+// clang-format off
+#ifdef WIFI_HAL_INTERFACE_COMBINATIONS
+constexpr ChipModeId kMainModeId = chip_mode_ids::kV3;
+#elif defined(WIFI_HIDL_FEATURE_DUAL_INTERFACE)
+// former V2 (fixed dual interface) setup expressed as V3
+constexpr ChipModeId kMainModeId = chip_mode_ids::kV3;
+#  ifdef WIFI_HIDL_FEATURE_DISABLE_AP
+#    ifdef WIFI_HIDL_FEATURE_AWARE
+//     1 STA + 1 of (P2P or NAN)
+#      define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{P2P, NAN}, 1}}
+#    else
+//     1 STA + 1 P2P
+#      define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{P2P}, 1}}
+#    endif
+#  else
+#    ifdef WIFI_HIDL_FEATURE_AWARE
+//     (1 STA + 1 AP) or (1 STA + 1 of (P2P or NAN))
+#      define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{AP}, 1}},\
+                                              {{{STA}, 1}, {{P2P, NAN}, 1}}
+#    else
+//     (1 STA + 1 AP) or (1 STA + 1 P2P)
+#      define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{AP}, 1}},\
+                                              {{{STA}, 1}, {{P2P}, 1}}
+#    endif
+#  endif
+#else
+// V1 (fixed single interface, dual-mode chip)
+constexpr ChipModeId kMainModeId = chip_mode_ids::kV1Sta;
+#  ifdef WIFI_HIDL_FEATURE_AWARE
+//   1 STA + 1 of (P2P or NAN)
+#    define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{P2P, NAN}, 1}}
+#  else
+//   1 STA + 1 P2P
+#    define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{P2P}, 1}}
+#  endif
+
+#  ifndef WIFI_HIDL_FEATURE_DISABLE_AP
+#    define WIFI_HAL_INTERFACE_COMBINATIONS_AP {{{AP}, 1}}
+#  endif
+#endif
+// clang-format on
+
+/**
+ * Helper class to convert a collection of combination limits to a combination.
+ *
+ * The main point here is to simplify the syntax required by
+ * WIFI_HAL_INTERFACE_COMBINATIONS.
+ */
+struct ChipConcurrencyCombination
+    : public hidl_vec<V1_6::IWifiChip::ChipConcurrencyCombinationLimit> {
+    ChipConcurrencyCombination(
+            const std::initializer_list<V1_6::IWifiChip::ChipConcurrencyCombinationLimit> list)
+        : hidl_vec(list) {}
+
+    operator V1_6::IWifiChip::ChipConcurrencyCombination() const { return {*this}; }
+
+    static hidl_vec<V1_6::IWifiChip::ChipConcurrencyCombination> make_vec(
+            const std::initializer_list<ChipConcurrencyCombination> list) {
+        return hidl_vec<V1_6::IWifiChip::ChipConcurrencyCombination>(  //
+                std::begin(list), std::end(list));
+    }
+};
+
+#define STA IfaceConcurrencyType::STA
+#define AP IfaceConcurrencyType::AP
+#define AP_BRIDGED IfaceConcurrencyType::AP_BRIDGED
+#define P2P IfaceConcurrencyType::P2P
+#define NAN IfaceConcurrencyType::NAN
+static const std::vector<V1_6::IWifiChip::ChipMode> kChipModesPrimary{
+        {kMainModeId, ChipConcurrencyCombination::make_vec({WIFI_HAL_INTERFACE_COMBINATIONS})},
+#ifdef WIFI_HAL_INTERFACE_COMBINATIONS_AP
+        {chip_mode_ids::kV1Ap,
+         ChipConcurrencyCombination::make_vec({WIFI_HAL_INTERFACE_COMBINATIONS_AP})},
+#endif
+};
+
+static const std::vector<V1_6::IWifiChip::ChipMode> kChipModesSecondary{
+#ifdef WIFI_HAL_INTERFACE_COMBINATIONS_SECONDARY_CHIP
+        {chip_mode_ids::kV3,
+         ChipConcurrencyCombination::make_vec({WIFI_HAL_INTERFACE_COMBINATIONS_SECONDARY_CHIP})},
+#endif
+};
+
+constexpr char kDebugPresetInterfaceCombinationIdxProperty[] =
+        "persist.vendor.debug.wifi.hal.preset_interface_combination_idx";
+// List of pre-defined concurrency combinations that can be enabled at runtime via
+// setting the property: "kDebugPresetInterfaceCombinationIdxProperty" to the
+// corresponding index value.
+static const std::vector<std::pair<std::string, std::vector<V1_6::IWifiChip::ChipMode>>>
+        kDebugChipModes{// Legacy combination - No STA/AP concurrencies.
+                        // 0 - (1 AP) or (1 STA + 1 of (P2P or NAN))
+                        {"No STA/AP Concurrency",
+                         {{kMainModeId, ChipConcurrencyCombination::make_vec(
+                                                {{{{AP}, 1}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
+
+                        // STA + AP concurrency
+                        // 1 - (1 STA + 1 AP) or (1 STA + 1 of (P2P or NAN))
+                        {"STA + AP Concurrency",
+                         {{kMainModeId,
+                           ChipConcurrencyCombination::make_vec(
+                                   {{{{STA}, 1}, {{AP}, 1}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
+
+                        // STA + STA concurrency
+                        // 2 - (1 STA + 1 AP) or (2 STA + 1 of (P2P or NAN))
+                        {"Dual STA Concurrency",
+                         {{kMainModeId,
+                           ChipConcurrencyCombination::make_vec(
+                                   {{{{STA}, 1}, {{AP}, 1}}, {{{STA}, 2}, {{P2P, NAN}, 1}}})}}},
+
+                        // AP + AP + STA concurrency
+                        // 3 - (1 STA + 2 AP) or (1 STA + 1 of (P2P or NAN))
+                        {"Dual AP Concurrency",
+                         {{kMainModeId,
+                           ChipConcurrencyCombination::make_vec(
+                                   {{{{STA}, 1}, {{AP}, 2}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
+
+                        // STA + STA concurrency and AP + AP + STA concurrency
+                        // 4 - (1 STA + 2 AP) or (2 STA + 1 of (P2P or NAN))
+                        {"Dual STA & Dual AP Concurrency",
+                         {{kMainModeId,
+                           ChipConcurrencyCombination::make_vec(
+                                   {{{{STA}, 1}, {{AP}, 2}}, {{{STA}, 2}, {{P2P, NAN}, 1}}})}}},
+
+                        // STA + STA concurrency
+                        // 5 - (1 STA + 1 AP (bridged or single) | P2P | NAN), or (2 STA))
+                        {"Dual STA or STA plus single other interface",
+                         {{kMainModeId, ChipConcurrencyCombination::make_vec(
+                                                {{{{STA}, 1}, {{P2P, NAN, AP, AP_BRIDGED}, 1}},
+                                                 {{{STA}, 2}}})}}}};
+
+#undef STA
+#undef AP
+#undef P2P
+#undef NAN
+
+#ifdef WIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION
+#pragma message                                                                   \
+        "WIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION is deprecated; override " \
+        "'config_wifi_ap_randomization_supported' in "                            \
+        "frameworks/base/core/res/res/values/config.xml in the device overlay "   \
+        "instead"
+#endif  // WIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION
+
+WifiFeatureFlags::WifiFeatureFlags() {}
+
+std::vector<V1_6::IWifiChip::ChipMode> WifiFeatureFlags::getChipModesForPrimary() {
+    std::array<char, PROPERTY_VALUE_MAX> buffer;
+    auto res = property_get(kDebugPresetInterfaceCombinationIdxProperty, buffer.data(), nullptr);
+    // Debug property not set, use the device preset concurrency combination.
+    if (res <= 0) return kChipModesPrimary;
+
+    // Debug property set, use one of the debug preset concurrency combination.
+    unsigned long idx = std::stoul(buffer.data());
+    if (idx >= kDebugChipModes.size()) {
+        LOG(ERROR) << "Invalid index set in property: "
+                   << kDebugPresetInterfaceCombinationIdxProperty;
+        return kChipModesPrimary;
+    }
+    std::string name;
+    std::vector<V1_6::IWifiChip::ChipMode> chip_modes;
+    std::tie(name, chip_modes) = kDebugChipModes[idx];
+    LOG(INFO) << "Using debug chip mode: <" << name
+              << "> set via property: " << kDebugPresetInterfaceCombinationIdxProperty;
+    return chip_modes;
+}
+
+std::vector<V1_6::IWifiChip::ChipMode> WifiFeatureFlags::getChipModes(bool is_primary) {
+    return (is_primary) ? getChipModesForPrimary() : kChipModesSecondary;
+}
+
+}  // namespace feature_flags
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
diff --git a/wifi/aidl/default/wifi_feature_flags.h b/wifi/1.6/default/wifi_feature_flags.h
similarity index 67%
rename from wifi/aidl/default/wifi_feature_flags.h
rename to wifi/1.6/default/wifi_feature_flags.h
index af1b6a6..1635341 100644
--- a/wifi/aidl/default/wifi_feature_flags.h
+++ b/wifi/1.6/default/wifi_feature_flags.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,23 +17,24 @@
 #ifndef WIFI_FEATURE_FLAGS_H_
 #define WIFI_FEATURE_FLAGS_H_
 
-#include <aidl/android/hardware/wifi/IWifiChip.h>
+#include <android/hardware/wifi/1.6/IWifiChip.h>
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace feature_flags {
 
 namespace chip_mode_ids {
 // These mode ID's should be unique (even across combo versions). Refer to
-// handleChipConfiguration() for its usage.
-constexpr uint32_t kInvalid = UINT32_MAX;
+// handleChipConfiguration() for it's usage.
+constexpr V1_0::ChipModeId kInvalid = UINT32_MAX;
 // Mode ID's for V1
-constexpr uint32_t kV1Sta = 0;
-constexpr uint32_t kV1Ap = 1;
+constexpr V1_0::ChipModeId kV1Sta = 0;
+constexpr V1_0::ChipModeId kV1Ap = 1;
 // Mode ID for V3
-constexpr uint32_t kV3 = 3;
+constexpr V1_0::ChipModeId kV3 = 3;
 }  // namespace chip_mode_ids
 
 class WifiFeatureFlags {
@@ -41,16 +42,17 @@
     WifiFeatureFlags();
     virtual ~WifiFeatureFlags() = default;
 
-    virtual std::vector<IWifiChip::ChipMode> getChipModes(bool is_primary);
+    virtual std::vector<V1_6::IWifiChip::ChipMode> getChipModes(bool is_primary);
 
   private:
-    std::vector<IWifiChip::ChipMode> getChipModesForPrimary();
+    std::vector<V1_6::IWifiChip::ChipMode> getChipModesForPrimary();
 };
 
 }  // namespace feature_flags
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
 
 #endif  // WIFI_FEATURE_FLAGS_H_
diff --git a/wifi/aidl/default/wifi_iface_util.cpp b/wifi/1.6/default/wifi_iface_util.cpp
similarity index 95%
rename from wifi/aidl/default/wifi_iface_util.cpp
rename to wifi/1.6/default/wifi_iface_util.cpp
index f788217..d55e4f8 100644
--- a/wifi/aidl/default/wifi_iface_util.cpp
+++ b/wifi/1.6/default/wifi_iface_util.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,32 +14,33 @@
  * limitations under the License.
  */
 
-#include <android-base/logging.h>
-#include <android-base/macros.h>
 #include <net/if.h>
-#include <private/android_filesystem_config.h>
-
 #include <cstddef>
 #include <iostream>
 #include <limits>
 #include <random>
 
+#include <android-base/logging.h>
+#include <android-base/macros.h>
+#include <private/android_filesystem_config.h>
+
+#undef NAN
 #include "wifi_iface_util.h"
 
 namespace {
 // Constants to set the local bit & clear the multicast bit.
 constexpr uint8_t kMacAddressMulticastMask = 0x01;
 constexpr uint8_t kMacAddressLocallyAssignedMask = 0x02;
-
 }  // namespace
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace iface_util {
 
-WifiIfaceUtil::WifiIfaceUtil(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
+WifiIfaceUtil::WifiIfaceUtil(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
                              const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
     : iface_tool_(iface_tool),
       legacy_hal_(legacy_hal),
@@ -168,7 +169,8 @@
 }
 
 }  // namespace iface_util
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/wifi_iface_util.h b/wifi/1.6/default/wifi_iface_util.h
similarity index 89%
rename from wifi/aidl/default/wifi_iface_util.h
rename to wifi/1.6/default/wifi_iface_util.h
index a3236a5..c5db5de 100644
--- a/wifi/aidl/default/wifi_iface_util.h
+++ b/wifi/1.6/default/wifi_iface_util.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,15 +17,17 @@
 #ifndef WIFI_IFACE_UTIL_H_
 #define WIFI_IFACE_UTIL_H_
 
-#include <aidl/android/hardware/wifi/IWifi.h>
 #include <wifi_system/interface_tool.h>
 
+#include <android/hardware/wifi/1.0/IWifi.h>
+
 #include "wifi_legacy_hal.h"
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace iface_util {
 
 // Iface event handlers.
@@ -40,7 +42,7 @@
  */
 class WifiIfaceUtil {
   public:
-    WifiIfaceUtil(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
+    WifiIfaceUtil(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
                   const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
     virtual ~WifiIfaceUtil() = default;
 
@@ -69,16 +71,17 @@
     virtual std::array<uint8_t, 6> createRandomMacAddress();
 
   private:
-    std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool_;
+    std::weak_ptr<wifi_system::InterfaceTool> iface_tool_;
     std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
     std::unique_ptr<std::array<uint8_t, 6>> random_mac_address_;
     std::map<std::string, IfaceEventHandlers> event_handlers_map_;
 };
 
 }  // namespace iface_util
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
 
 #endif  // WIFI_IFACE_UTIL_H_
diff --git a/wifi/aidl/default/wifi_legacy_hal.cpp b/wifi/1.6/default/wifi_legacy_hal.cpp
similarity index 94%
rename from wifi/aidl/default/wifi_legacy_hal.cpp
rename to wifi/1.6/default/wifi_legacy_hal.cpp
index 43e73ca..43cb7c4 100644
--- a/wifi/aidl/default/wifi_legacy_hal.cpp
+++ b/wifi/1.6/default/wifi_legacy_hal.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,16 +14,15 @@
  * limitations under the License.
  */
 
-#include "wifi_legacy_hal.h"
+#include <array>
+#include <chrono>
 
 #include <android-base/logging.h>
 #include <cutils/properties.h>
 #include <net/if.h>
 
-#include <array>
-#include <chrono>
-
-#include "aidl_sync_util.h"
+#include "hidl_sync_util.h"
+#include "wifi_legacy_hal.h"
 #include "wifi_legacy_hal_stubs.h"
 
 namespace {
@@ -39,7 +38,7 @@
 static constexpr uint32_t kMaxRingBuffers = 10;
 static constexpr uint32_t kMaxWifiUsableChannels = 256;
 static constexpr uint32_t kMaxSupportedRadioCombinationsMatrixLength = 256;
-// Need a long timeout (1000ms) for chips that unload their driver.
+// need a long timeout (1000ms) for chips that unload their driver.
 static constexpr uint32_t kMaxStopCompleteWaitMs = 1000;
 static constexpr char kDriverPropName[] = "wlan.driver.status";
 
@@ -52,10 +51,11 @@
 }
 }  // namespace
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace legacy_hal {
 
 // Legacy HAL functions accept "C" style function pointers, so use global
@@ -65,7 +65,7 @@
 // Callback to be invoked once |stop| is complete
 std::function<void(wifi_handle handle)> on_stop_complete_internal_callback;
 void onAsyncStopComplete(wifi_handle handle) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_stop_complete_internal_callback) {
         on_stop_complete_internal_callback(handle);
         // Invalidate this callback since we don't want this firing again.
@@ -92,7 +92,7 @@
 // Callback to be invoked for Gscan events.
 std::function<void(wifi_request_id, wifi_scan_event)> on_gscan_event_internal_callback;
 void onAsyncGscanEvent(wifi_request_id id, wifi_scan_event event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_gscan_event_internal_callback) {
         on_gscan_event_internal_callback(id, event);
     }
@@ -103,7 +103,7 @@
         on_gscan_full_result_internal_callback;
 void onAsyncGscanFullResult(wifi_request_id id, wifi_scan_result* result,
                             uint32_t buckets_scanned) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_gscan_full_result_internal_callback) {
         on_gscan_full_result_internal_callback(id, result, buckets_scanned);
     }
@@ -123,7 +123,7 @@
 std::function<void((wifi_request_id, uint8_t*, int8_t))>
         on_rssi_threshold_breached_internal_callback;
 void onAsyncRssiThresholdBreached(wifi_request_id id, uint8_t* bssid, int8_t rssi) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_rssi_threshold_breached_internal_callback) {
         on_rssi_threshold_breached_internal_callback(id, bssid, rssi);
     }
@@ -134,7 +134,7 @@
         on_ring_buffer_data_internal_callback;
 void onAsyncRingBufferData(char* ring_name, char* buffer, int buffer_size,
                            wifi_ring_buffer_status* status) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_ring_buffer_data_internal_callback) {
         on_ring_buffer_data_internal_callback(ring_name, buffer, buffer_size, status);
     }
@@ -143,7 +143,7 @@
 // Callback to be invoked for error alert indication.
 std::function<void(wifi_request_id, char*, int, int)> on_error_alert_internal_callback;
 void onAsyncErrorAlert(wifi_request_id id, char* buffer, int buffer_size, int err_code) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_error_alert_internal_callback) {
         on_error_alert_internal_callback(id, buffer, buffer_size, err_code);
     }
@@ -153,7 +153,7 @@
 std::function<void(wifi_request_id, uint32_t, wifi_mac_info*)>
         on_radio_mode_change_internal_callback;
 void onAsyncRadioModeChange(wifi_request_id id, uint32_t num_macs, wifi_mac_info* mac_infos) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_radio_mode_change_internal_callback) {
         on_radio_mode_change_internal_callback(id, num_macs, mac_infos);
     }
@@ -162,7 +162,7 @@
 // Callback to be invoked to report subsystem restart
 std::function<void(const char*)> on_subsystem_restart_internal_callback;
 void onAsyncSubsystemRestart(const char* error) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_subsystem_restart_internal_callback) {
         on_subsystem_restart_internal_callback(error);
     }
@@ -172,7 +172,7 @@
 std::function<void(wifi_request_id, unsigned num_results, wifi_rtt_result* rtt_results[])>
         on_rtt_results_internal_callback;
 void onAsyncRttResults(wifi_request_id id, unsigned num_results, wifi_rtt_result* rtt_results[]) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_rtt_results_internal_callback) {
         on_rtt_results_internal_callback(id, num_results, rtt_results);
         on_rtt_results_internal_callback = nullptr;
@@ -184,37 +184,37 @@
 // callbacks.
 // So, handle all of them here directly to avoid adding an unnecessary layer.
 std::function<void(transaction_id, const NanResponseMsg&)> on_nan_notify_response_user_callback;
-void onAsyncNanNotifyResponse(transaction_id id, NanResponseMsg* msg) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanNotifyResponse(transaction_id id, NanResponseMsg* msg) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_notify_response_user_callback && msg) {
         on_nan_notify_response_user_callback(id, *msg);
     }
 }
 
 std::function<void(const NanPublishRepliedInd&)> on_nan_event_publish_replied_user_callback;
-void onAsyncNanEventPublishReplied(NanPublishRepliedInd* /* event */) {
-    LOG(ERROR) << "onAsyncNanEventPublishReplied triggered";
+void onAysncNanEventPublishReplied(NanPublishRepliedInd* /* event */) {
+    LOG(ERROR) << "onAysncNanEventPublishReplied triggered";
 }
 
 std::function<void(const NanPublishTerminatedInd&)> on_nan_event_publish_terminated_user_callback;
-void onAsyncNanEventPublishTerminated(NanPublishTerminatedInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventPublishTerminated(NanPublishTerminatedInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_publish_terminated_user_callback && event) {
         on_nan_event_publish_terminated_user_callback(*event);
     }
 }
 
 std::function<void(const NanMatchInd&)> on_nan_event_match_user_callback;
-void onAsyncNanEventMatch(NanMatchInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventMatch(NanMatchInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_match_user_callback && event) {
         on_nan_event_match_user_callback(*event);
     }
 }
 
 std::function<void(const NanMatchExpiredInd&)> on_nan_event_match_expired_user_callback;
-void onAsyncNanEventMatchExpired(NanMatchExpiredInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventMatchExpired(NanMatchExpiredInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_match_expired_user_callback && event) {
         on_nan_event_match_expired_user_callback(*event);
     }
@@ -222,95 +222,95 @@
 
 std::function<void(const NanSubscribeTerminatedInd&)>
         on_nan_event_subscribe_terminated_user_callback;
-void onAsyncNanEventSubscribeTerminated(NanSubscribeTerminatedInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventSubscribeTerminated(NanSubscribeTerminatedInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_subscribe_terminated_user_callback && event) {
         on_nan_event_subscribe_terminated_user_callback(*event);
     }
 }
 
 std::function<void(const NanFollowupInd&)> on_nan_event_followup_user_callback;
-void onAsyncNanEventFollowup(NanFollowupInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventFollowup(NanFollowupInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_followup_user_callback && event) {
         on_nan_event_followup_user_callback(*event);
     }
 }
 
 std::function<void(const NanDiscEngEventInd&)> on_nan_event_disc_eng_event_user_callback;
-void onAsyncNanEventDiscEngEvent(NanDiscEngEventInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventDiscEngEvent(NanDiscEngEventInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_disc_eng_event_user_callback && event) {
         on_nan_event_disc_eng_event_user_callback(*event);
     }
 }
 
 std::function<void(const NanDisabledInd&)> on_nan_event_disabled_user_callback;
-void onAsyncNanEventDisabled(NanDisabledInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventDisabled(NanDisabledInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_disabled_user_callback && event) {
         on_nan_event_disabled_user_callback(*event);
     }
 }
 
 std::function<void(const NanTCAInd&)> on_nan_event_tca_user_callback;
-void onAsyncNanEventTca(NanTCAInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventTca(NanTCAInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_tca_user_callback && event) {
         on_nan_event_tca_user_callback(*event);
     }
 }
 
 std::function<void(const NanBeaconSdfPayloadInd&)> on_nan_event_beacon_sdf_payload_user_callback;
-void onAsyncNanEventBeaconSdfPayload(NanBeaconSdfPayloadInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventBeaconSdfPayload(NanBeaconSdfPayloadInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_beacon_sdf_payload_user_callback && event) {
         on_nan_event_beacon_sdf_payload_user_callback(*event);
     }
 }
 
 std::function<void(const NanDataPathRequestInd&)> on_nan_event_data_path_request_user_callback;
-void onAsyncNanEventDataPathRequest(NanDataPathRequestInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventDataPathRequest(NanDataPathRequestInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_data_path_request_user_callback && event) {
         on_nan_event_data_path_request_user_callback(*event);
     }
 }
 std::function<void(const NanDataPathConfirmInd&)> on_nan_event_data_path_confirm_user_callback;
-void onAsyncNanEventDataPathConfirm(NanDataPathConfirmInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventDataPathConfirm(NanDataPathConfirmInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_data_path_confirm_user_callback && event) {
         on_nan_event_data_path_confirm_user_callback(*event);
     }
 }
 
 std::function<void(const NanDataPathEndInd&)> on_nan_event_data_path_end_user_callback;
-void onAsyncNanEventDataPathEnd(NanDataPathEndInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventDataPathEnd(NanDataPathEndInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_data_path_end_user_callback && event) {
         on_nan_event_data_path_end_user_callback(*event);
     }
 }
 
 std::function<void(const NanTransmitFollowupInd&)> on_nan_event_transmit_follow_up_user_callback;
-void onAsyncNanEventTransmitFollowUp(NanTransmitFollowupInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventTransmitFollowUp(NanTransmitFollowupInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_transmit_follow_up_user_callback && event) {
         on_nan_event_transmit_follow_up_user_callback(*event);
     }
 }
 
 std::function<void(const NanRangeRequestInd&)> on_nan_event_range_request_user_callback;
-void onAsyncNanEventRangeRequest(NanRangeRequestInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventRangeRequest(NanRangeRequestInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_range_request_user_callback && event) {
         on_nan_event_range_request_user_callback(*event);
     }
 }
 
 std::function<void(const NanRangeReportInd&)> on_nan_event_range_report_user_callback;
-void onAsyncNanEventRangeReport(NanRangeReportInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+void onAysncNanEventRangeReport(NanRangeReportInd* event) {
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_range_report_user_callback && event) {
         on_nan_event_range_report_user_callback(*event);
     }
@@ -318,7 +318,7 @@
 
 std::function<void(const NanDataPathScheduleUpdateInd&)> on_nan_event_schedule_update_user_callback;
 void onAsyncNanEventScheduleUpdate(NanDataPathScheduleUpdateInd* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_nan_event_schedule_update_user_callback && event) {
         on_nan_event_schedule_update_user_callback(*event);
     }
@@ -327,7 +327,7 @@
 // Callbacks for the various TWT operations.
 std::function<void(const TwtSetupResponse&)> on_twt_event_setup_response_callback;
 void onAsyncTwtEventSetupResponse(TwtSetupResponse* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_twt_event_setup_response_callback && event) {
         on_twt_event_setup_response_callback(*event);
     }
@@ -335,7 +335,7 @@
 
 std::function<void(const TwtTeardownCompletion&)> on_twt_event_teardown_completion_callback;
 void onAsyncTwtEventTeardownCompletion(TwtTeardownCompletion* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_twt_event_teardown_completion_callback && event) {
         on_twt_event_teardown_completion_callback(*event);
     }
@@ -343,7 +343,7 @@
 
 std::function<void(const TwtInfoFrameReceived&)> on_twt_event_info_frame_received_callback;
 void onAsyncTwtEventInfoFrameReceived(TwtInfoFrameReceived* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_twt_event_info_frame_received_callback && event) {
         on_twt_event_info_frame_received_callback(*event);
     }
@@ -351,7 +351,7 @@
 
 std::function<void(const TwtDeviceNotify&)> on_twt_event_device_notify_callback;
 void onAsyncTwtEventDeviceNotify(TwtDeviceNotify* event) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_twt_event_device_notify_callback && event) {
         on_twt_event_device_notify_callback(*event);
     }
@@ -360,7 +360,7 @@
 // Callback to report current CHRE NAN state
 std::function<void(chre_nan_rtt_state)> on_chre_nan_rtt_internal_callback;
 void onAsyncChreNanRttState(chre_nan_rtt_state state) {
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (on_chre_nan_rtt_internal_callback) {
         on_chre_nan_rtt_internal_callback(state);
     }
@@ -376,7 +376,7 @@
 
 // End of the free-standing "C" style callbacks.
 
-WifiLegacyHal::WifiLegacyHal(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
+WifiLegacyHal::WifiLegacyHal(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
                              const wifi_hal_fn& fn, bool is_primary)
     : global_func_table_(fn),
       global_handle_(nullptr),
@@ -769,7 +769,7 @@
         if (!bssid_ptr) {
             return;
         }
-        std::array<uint8_t, ETH_ALEN> bssid_arr;
+        std::array<uint8_t, 6> bssid_arr;
         // |bssid_ptr| pointer is assumed to have 6 bytes for the mac
         // address.
         std::copy(bssid_ptr, bssid_ptr + 6, std::begin(bssid_arr));
@@ -820,12 +820,12 @@
     return global_func_table_.wifi_configure_nd_offload(getIfaceHandle(iface_name), enable);
 }
 
-wifi_error WifiLegacyHal::startSendingOffloadedPacket(const std::string& iface_name, int32_t cmd_id,
-                                                      uint16_t ether_type,
+wifi_error WifiLegacyHal::startSendingOffloadedPacket(const std::string& iface_name,
+                                                      uint32_t cmd_id, uint16_t ether_type,
                                                       const std::vector<uint8_t>& ip_packet_data,
                                                       const std::array<uint8_t, 6>& src_address,
                                                       const std::array<uint8_t, 6>& dst_address,
-                                                      int32_t period_in_ms) {
+                                                      uint32_t period_in_ms) {
     std::vector<uint8_t> ip_packet_data_internal(ip_packet_data);
     std::vector<uint8_t> src_address_internal(src_address.data(),
                                               src_address.data() + src_address.size());
@@ -1120,15 +1120,14 @@
 
 wifi_error WifiLegacyHal::cancelRttRangeRequest(
         const std::string& iface_name, wifi_request_id id,
-        const std::vector<std::array<uint8_t, ETH_ALEN>>& mac_addrs) {
+        const std::vector<std::array<uint8_t, 6>>& mac_addrs) {
     if (!on_rtt_results_internal_callback) {
         return WIFI_ERROR_NOT_AVAILABLE;
     }
-    static_assert(sizeof(mac_addr) == sizeof(std::array<uint8_t, ETH_ALEN>),
-                  "MAC address size mismatch");
+    static_assert(sizeof(mac_addr) == sizeof(std::array<uint8_t, 6>), "MAC address size mismatch");
     // TODO: How do we handle partial cancels (i.e only a subset of enabled mac
     // addressed are cancelled).
-    std::vector<std::array<uint8_t, ETH_ALEN>> mac_addrs_internal(mac_addrs);
+    std::vector<std::array<uint8_t, 6>> mac_addrs_internal(mac_addrs);
     wifi_error status = global_func_table_.wifi_rtt_range_cancel(
             id, getIfaceHandle(iface_name), mac_addrs.size(),
             reinterpret_cast<mac_addr*>(mac_addrs_internal.data()));
@@ -1203,14 +1202,14 @@
 
     return global_func_table_.wifi_nan_register_handler(
             getIfaceHandle(iface_name),
-            {onAsyncNanNotifyResponse, onAsyncNanEventPublishReplied,
-             onAsyncNanEventPublishTerminated, onAsyncNanEventMatch, onAsyncNanEventMatchExpired,
-             onAsyncNanEventSubscribeTerminated, onAsyncNanEventFollowup,
-             onAsyncNanEventDiscEngEvent, onAsyncNanEventDisabled, onAsyncNanEventTca,
-             onAsyncNanEventBeaconSdfPayload, onAsyncNanEventDataPathRequest,
-             onAsyncNanEventDataPathConfirm, onAsyncNanEventDataPathEnd,
-             onAsyncNanEventTransmitFollowUp, onAsyncNanEventRangeRequest,
-             onAsyncNanEventRangeReport, onAsyncNanEventScheduleUpdate});
+            {onAysncNanNotifyResponse, onAysncNanEventPublishReplied,
+             onAysncNanEventPublishTerminated, onAysncNanEventMatch, onAysncNanEventMatchExpired,
+             onAysncNanEventSubscribeTerminated, onAysncNanEventFollowup,
+             onAysncNanEventDiscEngEvent, onAysncNanEventDisabled, onAysncNanEventTca,
+             onAysncNanEventBeaconSdfPayload, onAysncNanEventDataPathRequest,
+             onAysncNanEventDataPathConfirm, onAysncNanEventDataPathEnd,
+             onAysncNanEventTransmitFollowUp, onAysncNanEventRangeRequest,
+             onAysncNanEventRangeReport, onAsyncNanEventScheduleUpdate});
 }
 
 wifi_error WifiLegacyHal::nanEnableRequest(const std::string& iface_name, transaction_id id,
@@ -1341,7 +1340,7 @@
 }
 
 wifi_error WifiLegacyHal::setCountryCode(const std::string& iface_name,
-                                         const std::array<uint8_t, 2> code) {
+                                         std::array<int8_t, 2> code) {
     std::string code_str(code.data(), code.data() + code.size());
     return global_func_table_.wifi_set_country_code(getIfaceHandle(iface_name), code_str.c_str());
 }
@@ -1385,7 +1384,7 @@
 void WifiLegacyHal::runEventLoop() {
     LOG(DEBUG) << "Starting legacy HAL event loop";
     global_func_table_.wifi_event_loop(global_handle_);
-    const auto lock = aidl_sync_util::acquireGlobalLock();
+    const auto lock = hidl_sync_util::acquireGlobalLock();
     if (!awaiting_event_loop_termination_) {
         LOG(FATAL) << "Legacy HAL event loop terminated, but HAL was not stopping";
     }
@@ -1648,7 +1647,8 @@
 }
 
 }  // namespace legacy_hal
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/wifi_legacy_hal.h b/wifi/1.6/default/wifi_legacy_hal.h
similarity index 97%
rename from wifi/aidl/default/wifi_legacy_hal.h
rename to wifi/1.6/default/wifi_legacy_hal.h
index cd8c0b1..1fd784a 100644
--- a/wifi/aidl/default/wifi_legacy_hal.h
+++ b/wifi/1.6/default/wifi_legacy_hal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,22 +17,22 @@
 #ifndef WIFI_LEGACY_HAL_H_
 #define WIFI_LEGACY_HAL_H_
 
-#include <hardware_legacy/wifi_hal.h>
-#include <wifi_system/interface_tool.h>
-
 #include <condition_variable>
 #include <functional>
 #include <map>
-#include <mutex>
 #include <thread>
 #include <vector>
 
-namespace aidl {
+#include <hardware_legacy/wifi_hal.h>
+#include <wifi_system/interface_tool.h>
+
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 // This is in a separate namespace to prevent typename conflicts between
-// the legacy HAL types and the AIDL interface types.
+// the legacy HAL types and the HIDL interface types.
 namespace legacy_hal {
 // Import all the types defined inside the legacy HAL header files into this
 // namespace.
@@ -411,7 +411,7 @@
 
 // Invoked when the rssi value breaches the thresholds set.
 using on_rssi_threshold_breached_callback =
-        std::function<void(wifi_request_id, std::array<uint8_t, ETH_ALEN>, int8_t)>;
+        std::function<void(wifi_request_id, std::array<uint8_t, 6>, int8_t)>;
 
 // Callback for RTT range request results.
 // Rtt results contain IE info and are hence passed by reference, to
@@ -481,8 +481,8 @@
  */
 class WifiLegacyHal {
   public:
-    WifiLegacyHal(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
-                  const wifi_hal_fn& fn, bool is_primary);
+    WifiLegacyHal(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool, const wifi_hal_fn& fn,
+                  bool is_primary);
     virtual ~WifiLegacyHal() = default;
 
     // Initialize the legacy HAL function table.
@@ -521,7 +521,7 @@
     //    |on_results_user_callback| on success.
     // b) |WIFI_SCAN_FAILED| scan event or failure to retrieve cached scan
     // results
-    //    Triggers the externally provided |on_failure_user_callback|.
+    //    triggers the externally provided |on_failure_user_callback|.
     // 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,
@@ -547,12 +547,12 @@
     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, int32_t cmd_id,
+    wifi_error startSendingOffloadedPacket(const std::string& iface_name, uint32_t cmd_id,
                                            uint16_t ether_type,
                                            const std::vector<uint8_t>& ip_packet_data,
                                            const std::array<uint8_t, 6>& src_address,
                                            const std::array<uint8_t, 6>& dst_address,
-                                           int32_t period_in_ms);
+                                           uint32_t period_in_ms);
     wifi_error stopSendingOffloadedPacket(const std::string& iface_name, uint32_t cmd_id);
     virtual wifi_error selectTxPowerScenario(const std::string& iface_name,
                                              wifi_power_scenario scenario);
@@ -591,7 +591,7 @@
                                     const std::vector<wifi_rtt_config>& rtt_configs,
                                     const on_rtt_results_callback& on_results_callback);
     wifi_error cancelRttRangeRequest(const std::string& iface_name, wifi_request_id id,
-                                     const std::vector<std::array<uint8_t, ETH_ALEN>>& mac_addrs);
+                                     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,
@@ -638,9 +638,9 @@
                                          const NanDataPathIndicationResponse& msg);
     wifi_error nanDataEnd(const std::string& iface_name, transaction_id id, uint32_t ndpInstanceId);
     // AP functions.
-    wifi_error setCountryCode(const std::string& iface_name, const std::array<uint8_t, 2> code);
+    wifi_error setCountryCode(const std::string& iface_name, std::array<int8_t, 2> code);
 
-    // Interface functions.
+    // interface functions.
     virtual wifi_error createVirtualInterface(const std::string& ifname,
                                               wifi_interface_type iftype);
     virtual wifi_error deleteVirtualInterface(const std::string& ifname);
@@ -721,8 +721,8 @@
     std::condition_variable_any stop_wait_cv_;
     // Flag to indicate if the legacy HAL has been started.
     bool is_started_;
-    std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool_;
-    // Flag to indicate if this HAL is for the primary chip. This is used
+    std::weak_ptr<wifi_system::InterfaceTool> iface_tool_;
+    // flag to indicate if this HAL is for the primary chip. This is used
     // in order to avoid some hard-coded behavior used with older HALs,
     // such as bring wlan0 interface up/down on start/stop HAL.
     // it may be removed once vendor HALs are updated.
@@ -730,9 +730,10 @@
 };
 
 }  // namespace legacy_hal
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
 
 #endif  // WIFI_LEGACY_HAL_H_
diff --git a/wifi/aidl/default/wifi_legacy_hal_factory.cpp b/wifi/1.6/default/wifi_legacy_hal_factory.cpp
similarity index 97%
rename from wifi/aidl/default/wifi_legacy_hal_factory.cpp
rename to wifi/1.6/default/wifi_legacy_hal_factory.cpp
index 60f81ed..147bf4d 100644
--- a/wifi/aidl/default/wifi_legacy_hal_factory.cpp
+++ b/wifi/1.6/default/wifi_legacy_hal_factory.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,17 +14,17 @@
  * limitations under the License.
  */
 
-#include "wifi_legacy_hal_factory.h"
+#include <dirent.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 
 #include <android-base/logging.h>
-#include <dirent.h>
 #include <dlfcn.h>
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 #include <libxml/xmlmemory.h>
-#include <sys/stat.h>
-#include <sys/types.h>
 
+#include "wifi_legacy_hal_factory.h"
 #include "wifi_legacy_hal_stubs.h"
 
 namespace {
@@ -59,14 +59,15 @@
 }
 };  // namespace
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace legacy_hal {
 
 WifiLegacyHalFactory::WifiLegacyHalFactory(
-        const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool)
+        const std::weak_ptr<wifi_system::InterfaceTool> iface_tool)
     : iface_tool_(iface_tool) {}
 
 std::vector<std::shared_ptr<WifiLegacyHal>> WifiLegacyHalFactory::getHals() {
@@ -246,7 +247,8 @@
 }
 
 }  // namespace legacy_hal
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/wifi_legacy_hal_factory.h b/wifi/1.6/default/wifi_legacy_hal_factory.h
similarity index 82%
rename from wifi/aidl/default/wifi_legacy_hal_factory.h
rename to wifi/1.6/default/wifi_legacy_hal_factory.h
index e7b287a..9f4423e 100644
--- a/wifi/aidl/default/wifi_legacy_hal_factory.h
+++ b/wifi/1.6/default/wifi_legacy_hal_factory.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,19 +21,20 @@
 
 #include "wifi_legacy_hal.h"
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 // This is in a separate namespace to prevent typename conflicts between
-// the legacy HAL types and the AIDL interface types.
+// the legacy HAL types and the HIDL interface types.
 namespace legacy_hal {
 /**
  * Class that creates WifiLegacyHal objects for vendor HALs in the system.
  */
 class WifiLegacyHalFactory {
   public:
-    WifiLegacyHalFactory(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool);
+    WifiLegacyHalFactory(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool);
     virtual ~WifiLegacyHalFactory() = default;
 
     std::vector<std::shared_ptr<WifiLegacyHal>> getHals();
@@ -50,15 +51,16 @@
     bool initLinkedHalFunctionTable(wifi_hal_fn* hal_fn);
     bool loadVendorHalLib(const std::string& path, wifi_hal_lib_desc& desc);
 
-    std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool_;
+    std::weak_ptr<wifi_system::InterfaceTool> iface_tool_;
     std::vector<wifi_hal_lib_desc> descs_;
     std::vector<std::shared_ptr<WifiLegacyHal>> legacy_hals_;
 };
 
 }  // namespace legacy_hal
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
 
 #endif  // WIFI_LEGACY_HAL_FACTORY_H_
diff --git a/wifi/aidl/default/wifi_legacy_hal_stubs.cpp b/wifi/1.6/default/wifi_legacy_hal_stubs.cpp
similarity index 97%
rename from wifi/aidl/default/wifi_legacy_hal_stubs.cpp
rename to wifi/1.6/default/wifi_legacy_hal_stubs.cpp
index cff7f69..8f8527a 100644
--- a/wifi/aidl/default/wifi_legacy_hal_stubs.cpp
+++ b/wifi/1.6/default/wifi_legacy_hal_stubs.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,10 +17,11 @@
 #include "wifi_legacy_hal_stubs.h"
 
 // TODO: Remove these stubs from HalTool in libwifi-system.
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace legacy_hal {
 template <typename>
 struct stubFunction;
@@ -169,9 +170,9 @@
     populateStubFor(&hal_fn->wifi_get_cached_scan_results);
     return true;
 }
-
 }  // namespace legacy_hal
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/wifi_legacy_hal_stubs.h b/wifi/1.6/default/wifi_legacy_hal_stubs.h
similarity index 86%
rename from wifi/aidl/default/wifi_legacy_hal_stubs.h
rename to wifi/1.6/default/wifi_legacy_hal_stubs.h
index 603ecf2..c9a03bf 100644
--- a/wifi/aidl/default/wifi_legacy_hal_stubs.h
+++ b/wifi/1.6/default/wifi_legacy_hal_stubs.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,17 +19,19 @@
 
 #include <hardware_legacy/wifi_hal.h>
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace legacy_hal {
 
 bool initHalFuncTableWithStubs(wifi_hal_fn* hal_fn);
 }  // namespace legacy_hal
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
 
 #endif  // WIFI_LEGACY_HAL_STUBS_H_
diff --git a/wifi/aidl/default/wifi_mode_controller.cpp b/wifi/1.6/default/wifi_mode_controller.cpp
similarity index 90%
rename from wifi/aidl/default/wifi_mode_controller.cpp
rename to wifi/1.6/default/wifi_mode_controller.cpp
index 07cb072..4b8ac7d 100644
--- a/wifi/aidl/default/wifi_mode_controller.cpp
+++ b/wifi/1.6/default/wifi_mode_controller.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 
-#include "wifi_mode_controller.h"
-
 #include <android-base/logging.h>
 #include <android-base/macros.h>
 #include <private/android_filesystem_config.h>
 
-namespace {
-using aidl::android::hardware::wifi::IfaceType;
+#include "wifi_mode_controller.h"
+
+using android::hardware::wifi::V1_0::IfaceType;
 using android::wifi_hal::DriverTool;
 
+namespace {
 int convertIfaceTypeToFirmwareMode(IfaceType type) {
     int mode;
     switch (type) {
@@ -33,7 +33,7 @@
         case IfaceType::P2P:
             mode = DriverTool::kFirmwareModeP2p;
             break;
-        case IfaceType::NAN_IFACE:
+        case IfaceType::NAN:
             // NAN is exposed in STA mode currently.
             mode = DriverTool::kFirmwareModeSta;
             break;
@@ -45,10 +45,11 @@
 }
 }  // namespace
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace mode_controller {
 
 WifiModeController::WifiModeController() : driver_tool_(new DriverTool) {}
@@ -80,9 +81,9 @@
     }
     return true;
 }
-
 }  // namespace mode_controller
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/wifi_mode_controller.h b/wifi/1.6/default/wifi_mode_controller.h
similarity index 84%
rename from wifi/aidl/default/wifi_mode_controller.h
rename to wifi/1.6/default/wifi_mode_controller.h
index 1a9fb1a..fee2b66 100644
--- a/wifi/aidl/default/wifi_mode_controller.h
+++ b/wifi/1.6/default/wifi_mode_controller.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,14 +17,17 @@
 #ifndef WIFI_MODE_CONTROLLER_H_
 #define WIFI_MODE_CONTROLLER_H_
 
-#include <aidl/android/hardware/wifi/IWifi.h>
 #include <wifi_hal/driver_tool.h>
 
-namespace aidl {
+#include <android/hardware/wifi/1.0/IWifi.h>
+
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 namespace mode_controller {
+using namespace android::hardware::wifi::V1_0;
 
 /**
  * Class that encapsulates all firmware mode configuration.
@@ -47,13 +50,14 @@
     virtual bool deinitialize();
 
   private:
-    std::unique_ptr<::android::wifi_hal::DriverTool> driver_tool_;
+    std::unique_ptr<wifi_hal::DriverTool> driver_tool_;
 };
 
 }  // namespace mode_controller
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
 
 #endif  // WIFI_MODE_CONTROLLER_H_
diff --git a/wifi/1.6/default/wifi_nan_iface.cpp b/wifi/1.6/default/wifi_nan_iface.cpp
new file mode 100644
index 0000000..ac2ebc9
--- /dev/null
+++ b/wifi/1.6/default/wifi_nan_iface.cpp
@@ -0,0 +1,1016 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <android-base/logging.h>
+
+#include "hidl_return_util.h"
+#include "hidl_struct_util.h"
+#include "wifi_nan_iface.h"
+#include "wifi_status_util.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+using hidl_return_util::validateAndCall;
+
+WifiNanIface::WifiNanIface(const std::string& ifname, bool is_dedicated_iface,
+                           const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
+                           const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
+    : ifname_(ifname),
+      is_dedicated_iface_(is_dedicated_iface),
+      legacy_hal_(legacy_hal),
+      iface_util_(iface_util),
+      is_valid_(true) {
+    if (is_dedicated_iface_) {
+        // If using a dedicated iface, set the iface up first.
+        if (!iface_util_.lock()->setUpState(ifname_, true)) {
+            // Fatal failure, invalidate the iface object.
+            invalidate();
+            return;
+        }
+    }
+    // Register all the callbacks here. these should be valid for the lifetime
+    // of the object. Whenever the mode changes legacy HAL will remove
+    // all of these callbacks.
+    legacy_hal::NanCallbackHandlers callback_handlers;
+    android::wp<WifiNanIface> weak_ptr_this(this);
+
+    // Callback for response.
+    callback_handlers.on_notify_response = [weak_ptr_this](legacy_hal::transaction_id id,
+                                                           const legacy_hal::NanResponseMsg& msg) {
+        const auto shared_ptr_this = weak_ptr_this.promote();
+        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+            LOG(ERROR) << "Callback invoked on an invalid object";
+            return;
+        }
+        WifiNanStatus wifiNanStatus;
+        if (!hidl_struct_util::convertLegacyNanResponseHeaderToHidl(msg, &wifiNanStatus)) {
+            LOG(ERROR) << "Failed to convert nan response header";
+            return;
+        }
+
+        switch (msg.response_type) {
+            case legacy_hal::NAN_RESPONSE_ENABLED: {
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->notifyEnableResponse(id, wifiNanStatus).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+                break;
+            }
+            case legacy_hal::NAN_RESPONSE_DISABLED: {
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->notifyDisableResponse(id, wifiNanStatus).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+                break;
+            }
+            case legacy_hal::NAN_RESPONSE_PUBLISH: {
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->notifyStartPublishResponse(id, wifiNanStatus,
+                                                              msg.body.publish_response.publish_id)
+                                 .isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+                break;
+            }
+            case legacy_hal::NAN_RESPONSE_PUBLISH_CANCEL: {
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->notifyStopPublishResponse(id, wifiNanStatus).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+                break;
+            }
+            case legacy_hal::NAN_RESPONSE_TRANSMIT_FOLLOWUP: {
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->notifyTransmitFollowupResponse(id, wifiNanStatus).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+                break;
+            }
+            case legacy_hal::NAN_RESPONSE_SUBSCRIBE: {
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->notifyStartSubscribeResponse(
+                                         id, wifiNanStatus,
+                                         msg.body.subscribe_response.subscribe_id)
+                                 .isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+                break;
+            }
+            case legacy_hal::NAN_RESPONSE_SUBSCRIBE_CANCEL: {
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->notifyStopSubscribeResponse(id, wifiNanStatus).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+                break;
+            }
+            case legacy_hal::NAN_RESPONSE_CONFIG: {
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->notifyConfigResponse(id, wifiNanStatus).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+                break;
+            }
+            case legacy_hal::NAN_GET_CAPABILITIES: {
+                V1_6::NanCapabilities hidl_struct;
+                if (!hidl_struct_util::convertLegacyNanCapabilitiesResponseToHidl(
+                            msg.body.nan_capabilities, &hidl_struct)) {
+                    LOG(ERROR) << "Failed to convert nan capabilities response";
+                    return;
+                }
+                for (const auto& callback : shared_ptr_this->getEventCallbacks_1_6()) {
+                    if (!callback->notifyCapabilitiesResponse_1_6(id, wifiNanStatus, hidl_struct)
+                                 .isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+                break;
+            }
+            case legacy_hal::NAN_DP_INTERFACE_CREATE: {
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->notifyCreateDataInterfaceResponse(id, wifiNanStatus).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+                break;
+            }
+            case legacy_hal::NAN_DP_INTERFACE_DELETE: {
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->notifyDeleteDataInterfaceResponse(id, wifiNanStatus).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+                break;
+            }
+            case legacy_hal::NAN_DP_INITIATOR_RESPONSE: {
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->notifyInitiateDataPathResponse(
+                                         id, wifiNanStatus,
+                                         msg.body.data_request_response.ndp_instance_id)
+                                 .isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+                break;
+            }
+            case legacy_hal::NAN_DP_RESPONDER_RESPONSE: {
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->notifyRespondToDataPathIndicationResponse(id, wifiNanStatus)
+                                 .isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+                break;
+            }
+            case legacy_hal::NAN_DP_END: {
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->notifyTerminateDataPathResponse(id, wifiNanStatus).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+                break;
+            }
+            case legacy_hal::NAN_RESPONSE_BEACON_SDF_PAYLOAD:
+            /* fall through */
+            case legacy_hal::NAN_RESPONSE_TCA:
+            /* fall through */
+            case legacy_hal::NAN_RESPONSE_STATS:
+            /* fall through */
+            case legacy_hal::NAN_RESPONSE_ERROR:
+            /* fall through */
+            default:
+                LOG(ERROR) << "Unknown or unhandled response type: " << msg.response_type;
+                return;
+        }
+    };
+
+    callback_handlers.on_event_disc_eng_event =
+            [weak_ptr_this](const legacy_hal::NanDiscEngEventInd& msg) {
+                const auto shared_ptr_this = weak_ptr_this.promote();
+                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+                    LOG(ERROR) << "Callback invoked on an invalid object";
+                    return;
+                }
+                NanClusterEventInd hidl_struct;
+                // event types defined identically - hence can be cast
+                hidl_struct.eventType = (NanClusterEventType)msg.event_type;
+                hidl_struct.addr = msg.data.mac_addr.addr;
+
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->eventClusterEvent(hidl_struct).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+            };
+
+    callback_handlers.on_event_disabled = [weak_ptr_this](const legacy_hal::NanDisabledInd& msg) {
+        const auto shared_ptr_this = weak_ptr_this.promote();
+        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+            LOG(ERROR) << "Callback invoked on an invalid object";
+            return;
+        }
+        WifiNanStatus status;
+        hidl_struct_util::convertToWifiNanStatus(msg.reason, msg.nan_reason, sizeof(msg.nan_reason),
+                                                 &status);
+
+        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+            if (!callback->eventDisabled(status).isOk()) {
+                LOG(ERROR) << "Failed to invoke the callback";
+            }
+        }
+    };
+
+    callback_handlers.on_event_publish_terminated =
+            [weak_ptr_this](const legacy_hal::NanPublishTerminatedInd& msg) {
+                const auto shared_ptr_this = weak_ptr_this.promote();
+                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+                    LOG(ERROR) << "Callback invoked on an invalid object";
+                    return;
+                }
+                WifiNanStatus status;
+                hidl_struct_util::convertToWifiNanStatus(msg.reason, msg.nan_reason,
+                                                         sizeof(msg.nan_reason), &status);
+
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->eventPublishTerminated(msg.publish_id, status).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+            };
+
+    callback_handlers.on_event_subscribe_terminated =
+            [weak_ptr_this](const legacy_hal::NanSubscribeTerminatedInd& msg) {
+                const auto shared_ptr_this = weak_ptr_this.promote();
+                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+                    LOG(ERROR) << "Callback invoked on an invalid object";
+                    return;
+                }
+                WifiNanStatus status;
+                hidl_struct_util::convertToWifiNanStatus(msg.reason, msg.nan_reason,
+                                                         sizeof(msg.nan_reason), &status);
+
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->eventSubscribeTerminated(msg.subscribe_id, status).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+            };
+
+    callback_handlers.on_event_match = [weak_ptr_this](const legacy_hal::NanMatchInd& msg) {
+        const auto shared_ptr_this = weak_ptr_this.promote();
+        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+            LOG(ERROR) << "Callback invoked on an invalid object";
+            return;
+        }
+        V1_6::NanMatchInd hidl_struct;
+        if (!hidl_struct_util::convertLegacyNanMatchIndToHidl(msg, &hidl_struct)) {
+            LOG(ERROR) << "Failed to convert nan capabilities response";
+            return;
+        }
+
+        for (const auto& callback : shared_ptr_this->getEventCallbacks_1_6()) {
+            if (!callback->eventMatch_1_6(hidl_struct).isOk()) {
+                LOG(ERROR) << "Failed to invoke the callback";
+            }
+        }
+    };
+
+    callback_handlers.on_event_match_expired = [weak_ptr_this](
+                                                       const legacy_hal::NanMatchExpiredInd& msg) {
+        const auto shared_ptr_this = weak_ptr_this.promote();
+        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+            LOG(ERROR) << "Callback invoked on an invalid object";
+            return;
+        }
+        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+            if (!callback->eventMatchExpired(msg.publish_subscribe_id, msg.requestor_instance_id)
+                         .isOk()) {
+                LOG(ERROR) << "Failed to invoke the callback";
+            }
+        }
+    };
+
+    callback_handlers.on_event_followup = [weak_ptr_this](const legacy_hal::NanFollowupInd& msg) {
+        const auto shared_ptr_this = weak_ptr_this.promote();
+        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+            LOG(ERROR) << "Callback invoked on an invalid object";
+            return;
+        }
+        NanFollowupReceivedInd hidl_struct;
+        if (!hidl_struct_util::convertLegacyNanFollowupIndToHidl(msg, &hidl_struct)) {
+            LOG(ERROR) << "Failed to convert nan capabilities response";
+            return;
+        }
+
+        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+            if (!callback->eventFollowupReceived(hidl_struct).isOk()) {
+                LOG(ERROR) << "Failed to invoke the callback";
+            }
+        }
+    };
+
+    callback_handlers.on_event_transmit_follow_up =
+            [weak_ptr_this](const legacy_hal::NanTransmitFollowupInd& msg) {
+                const auto shared_ptr_this = weak_ptr_this.promote();
+                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+                    LOG(ERROR) << "Callback invoked on an invalid object";
+                    return;
+                }
+                WifiNanStatus status;
+                hidl_struct_util::convertToWifiNanStatus(msg.reason, msg.nan_reason,
+                                                         sizeof(msg.nan_reason), &status);
+
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->eventTransmitFollowup(msg.id, status).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+            };
+
+    callback_handlers.on_event_data_path_request =
+            [weak_ptr_this](const legacy_hal::NanDataPathRequestInd& msg) {
+                const auto shared_ptr_this = weak_ptr_this.promote();
+                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+                    LOG(ERROR) << "Callback invoked on an invalid object";
+                    return;
+                }
+                NanDataPathRequestInd hidl_struct;
+                if (!hidl_struct_util::convertLegacyNanDataPathRequestIndToHidl(msg,
+                                                                                &hidl_struct)) {
+                    LOG(ERROR) << "Failed to convert nan capabilities response";
+                    return;
+                }
+
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->eventDataPathRequest(hidl_struct).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+            };
+
+    callback_handlers.on_event_data_path_confirm =
+            [weak_ptr_this](const legacy_hal::NanDataPathConfirmInd& msg) {
+                const auto shared_ptr_this = weak_ptr_this.promote();
+                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+                    LOG(ERROR) << "Callback invoked on an invalid object";
+                    return;
+                }
+                V1_6::NanDataPathConfirmInd hidl_struct;
+                if (!hidl_struct_util::convertLegacyNanDataPathConfirmIndToHidl(msg,
+                                                                                &hidl_struct)) {
+                    LOG(ERROR) << "Failed to convert nan capabilities response";
+                    return;
+                }
+
+                for (const auto& callback : shared_ptr_this->getEventCallbacks_1_6()) {
+                    if (!callback->eventDataPathConfirm_1_6(hidl_struct).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+            };
+
+    callback_handlers.on_event_data_path_end =
+            [weak_ptr_this](const legacy_hal::NanDataPathEndInd& msg) {
+                const auto shared_ptr_this = weak_ptr_this.promote();
+                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+                    LOG(ERROR) << "Callback invoked on an invalid object";
+                    return;
+                }
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    for (int i = 0; i < msg.num_ndp_instances; ++i) {
+                        if (!callback->eventDataPathTerminated(msg.ndp_instance_id[i]).isOk()) {
+                            LOG(ERROR) << "Failed to invoke the callback";
+                        }
+                    }
+                }
+            };
+
+    callback_handlers.on_event_beacon_sdf_payload =
+            [weak_ptr_this](const legacy_hal::NanBeaconSdfPayloadInd& /* msg */) {
+                LOG(ERROR) << "on_event_beacon_sdf_payload - should not be called";
+            };
+
+    callback_handlers.on_event_range_request =
+            [weak_ptr_this](const legacy_hal::NanRangeRequestInd& /* msg */) {
+                LOG(ERROR) << "on_event_range_request - should not be called";
+            };
+
+    callback_handlers.on_event_range_report =
+            [weak_ptr_this](const legacy_hal::NanRangeReportInd& /* msg */) {
+                LOG(ERROR) << "on_event_range_report - should not be called";
+            };
+
+    callback_handlers.on_event_schedule_update =
+            [weak_ptr_this](const legacy_hal::NanDataPathScheduleUpdateInd& msg) {
+                const auto shared_ptr_this = weak_ptr_this.promote();
+                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+                    LOG(ERROR) << "Callback invoked on an invalid object";
+                    return;
+                }
+                V1_6::NanDataPathScheduleUpdateInd hidl_struct;
+                if (!hidl_struct_util::convertLegacyNanDataPathScheduleUpdateIndToHidl(
+                            msg, &hidl_struct)) {
+                    LOG(ERROR) << "Failed to convert nan capabilities response";
+                    return;
+                }
+
+                for (const auto& callback : shared_ptr_this->getEventCallbacks_1_6()) {
+                    if (!callback->eventDataPathScheduleUpdate_1_6(hidl_struct).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+            };
+
+    legacy_hal::wifi_error legacy_status =
+            legacy_hal_.lock()->nanRegisterCallbackHandlers(ifname_, callback_handlers);
+    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
+        LOG(ERROR) << "Failed to register nan callbacks. Invalidating object";
+        invalidate();
+    }
+
+    // Register for iface state toggle events.
+    iface_util::IfaceEventHandlers event_handlers = {};
+    event_handlers.on_state_toggle_off_on = [weak_ptr_this](const std::string& /* iface_name */) {
+        const auto shared_ptr_this = weak_ptr_this.promote();
+        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+            LOG(ERROR) << "Callback invoked on an invalid object";
+            return;
+        }
+        // Tell framework that NAN has been disabled.
+        WifiNanStatus status = {NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED, ""};
+        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+            if (!callback->eventDisabled(status).isOk()) {
+                LOG(ERROR) << "Failed to invoke the callback";
+            }
+        }
+    };
+    iface_util_.lock()->registerIfaceEventHandlers(ifname_, event_handlers);
+}
+
+void WifiNanIface::invalidate() {
+    if (!isValid()) {
+        return;
+    }
+    // send commands to HAL to actually disable and destroy interfaces
+    legacy_hal_.lock()->nanDisableRequest(ifname_, 0xFFFF);
+    legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, 0xFFFE, "aware_data0");
+    legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, 0xFFFD, "aware_data1");
+    iface_util_.lock()->unregisterIfaceEventHandlers(ifname_);
+    legacy_hal_.reset();
+    event_cb_handler_.invalidate();
+    event_cb_handler_1_2_.invalidate();
+    event_cb_handler_1_5_.invalidate();
+    is_valid_ = false;
+    if (is_dedicated_iface_) {
+        // If using a dedicated iface, set the iface down.
+        iface_util_.lock()->setUpState(ifname_, false);
+    }
+}
+
+bool WifiNanIface::isValid() {
+    return is_valid_;
+}
+
+std::string WifiNanIface::getName() {
+    return ifname_;
+}
+
+std::set<sp<V1_0::IWifiNanIfaceEventCallback>> WifiNanIface::getEventCallbacks() {
+    return event_cb_handler_.getCallbacks();
+}
+
+std::set<sp<V1_2::IWifiNanIfaceEventCallback>> WifiNanIface::getEventCallbacks_1_2() {
+    return event_cb_handler_1_2_.getCallbacks();
+}
+
+std::set<sp<V1_5::IWifiNanIfaceEventCallback>> WifiNanIface::getEventCallbacks_1_5() {
+    return event_cb_handler_1_5_.getCallbacks();
+}
+
+std::set<sp<V1_6::IWifiNanIfaceEventCallback>> WifiNanIface::getEventCallbacks_1_6() {
+    return event_cb_handler_1_6_.getCallbacks();
+}
+
+Return<void> WifiNanIface::getName(getName_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::getNameInternal, hidl_status_cb);
+}
+
+Return<void> WifiNanIface::getType(getType_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::getTypeInternal, hidl_status_cb);
+}
+
+Return<void> WifiNanIface::registerEventCallback(
+        const sp<V1_0::IWifiNanIfaceEventCallback>& callback,
+        registerEventCallback_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::registerEventCallbackInternal, hidl_status_cb, callback);
+}
+
+Return<void> WifiNanIface::getCapabilitiesRequest(uint16_t cmd_id,
+                                                  getCapabilitiesRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::getCapabilitiesRequestInternal, hidl_status_cb, cmd_id);
+}
+
+Return<void> WifiNanIface::enableRequest(uint16_t cmd_id, const V1_0::NanEnableRequest& msg,
+                                         enableRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::enableRequestInternal, hidl_status_cb, cmd_id, msg);
+}
+
+Return<void> WifiNanIface::configRequest(uint16_t cmd_id, const V1_0::NanConfigRequest& msg,
+                                         configRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::configRequestInternal, hidl_status_cb, cmd_id, msg);
+}
+
+Return<void> WifiNanIface::disableRequest(uint16_t cmd_id, disableRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::disableRequestInternal, hidl_status_cb, cmd_id);
+}
+
+Return<void> WifiNanIface::startPublishRequest(uint16_t cmd_id, const V1_0::NanPublishRequest& msg,
+                                               startPublishRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::startPublishRequestInternal, hidl_status_cb, cmd_id, msg);
+}
+
+Return<void> WifiNanIface::stopPublishRequest(uint16_t cmd_id, uint8_t sessionId,
+                                              stopPublishRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::stopPublishRequestInternal, hidl_status_cb, cmd_id,
+                           sessionId);
+}
+
+Return<void> WifiNanIface::startSubscribeRequest(uint16_t cmd_id,
+                                                 const V1_0::NanSubscribeRequest& msg,
+                                                 startSubscribeRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::startSubscribeRequestInternal, hidl_status_cb, cmd_id,
+                           msg);
+}
+
+Return<void> WifiNanIface::stopSubscribeRequest(uint16_t cmd_id, uint8_t sessionId,
+                                                stopSubscribeRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::stopSubscribeRequestInternal, hidl_status_cb, cmd_id,
+                           sessionId);
+}
+
+Return<void> WifiNanIface::transmitFollowupRequest(uint16_t cmd_id,
+                                                   const NanTransmitFollowupRequest& msg,
+                                                   transmitFollowupRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::transmitFollowupRequestInternal, hidl_status_cb, cmd_id,
+                           msg);
+}
+
+Return<void> WifiNanIface::createDataInterfaceRequest(
+        uint16_t cmd_id, const hidl_string& iface_name,
+        createDataInterfaceRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::createDataInterfaceRequestInternal, hidl_status_cb,
+                           cmd_id, iface_name);
+}
+
+Return<void> WifiNanIface::deleteDataInterfaceRequest(
+        uint16_t cmd_id, const hidl_string& iface_name,
+        deleteDataInterfaceRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::deleteDataInterfaceRequestInternal, hidl_status_cb,
+                           cmd_id, iface_name);
+}
+
+Return<void> WifiNanIface::initiateDataPathRequest(uint16_t cmd_id,
+                                                   const V1_0::NanInitiateDataPathRequest& msg,
+                                                   initiateDataPathRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::initiateDataPathRequestInternal, hidl_status_cb, cmd_id,
+                           msg);
+}
+
+Return<void> WifiNanIface::respondToDataPathIndicationRequest(
+        uint16_t cmd_id, const V1_0::NanRespondToDataPathIndicationRequest& msg,
+        respondToDataPathIndicationRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::respondToDataPathIndicationRequestInternal,
+                           hidl_status_cb, cmd_id, msg);
+}
+
+Return<void> WifiNanIface::terminateDataPathRequest(uint16_t cmd_id, uint32_t ndpInstanceId,
+                                                    terminateDataPathRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::terminateDataPathRequestInternal, hidl_status_cb, cmd_id,
+                           ndpInstanceId);
+}
+
+Return<void> WifiNanIface::registerEventCallback_1_2(
+        const sp<V1_2::IWifiNanIfaceEventCallback>& callback,
+        registerEventCallback_1_2_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::registerEventCallback_1_2Internal, hidl_status_cb,
+                           callback);
+}
+
+Return<void> WifiNanIface::enableRequest_1_2(uint16_t cmd_id, const V1_0::NanEnableRequest& msg1,
+                                             const V1_2::NanConfigRequestSupplemental& msg2,
+                                             enableRequest_1_2_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::enableRequest_1_2Internal, hidl_status_cb, cmd_id, msg1,
+                           msg2);
+}
+
+Return<void> WifiNanIface::configRequest_1_2(uint16_t cmd_id, const V1_0::NanConfigRequest& msg1,
+                                             const V1_2::NanConfigRequestSupplemental& msg2,
+                                             configRequest_1_2_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::configRequest_1_2Internal, hidl_status_cb, cmd_id, msg1,
+                           msg2);
+}
+
+Return<void> WifiNanIface::enableRequest_1_4(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
+                                             const V1_2::NanConfigRequestSupplemental& msg2,
+                                             enableRequest_1_4_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::enableRequest_1_4Internal, hidl_status_cb, cmd_id, msg1,
+                           msg2);
+}
+
+Return<void> WifiNanIface::configRequest_1_4(uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
+                                             const V1_2::NanConfigRequestSupplemental& msg2,
+                                             configRequest_1_4_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::configRequest_1_4Internal, hidl_status_cb, cmd_id, msg1,
+                           msg2);
+}
+
+Return<void> WifiNanIface::registerEventCallback_1_5(
+        const sp<V1_5::IWifiNanIfaceEventCallback>& callback,
+        registerEventCallback_1_5_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::registerEventCallback_1_5Internal, hidl_status_cb,
+                           callback);
+}
+
+Return<void> WifiNanIface::enableRequest_1_5(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
+                                             const V1_5::NanConfigRequestSupplemental& msg2,
+                                             enableRequest_1_5_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::enableRequest_1_5Internal, hidl_status_cb, cmd_id, msg1,
+                           msg2);
+}
+
+Return<void> WifiNanIface::configRequest_1_5(uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
+                                             const V1_5::NanConfigRequestSupplemental& msg2,
+                                             configRequest_1_5_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::configRequest_1_5Internal, hidl_status_cb, cmd_id, msg1,
+                           msg2);
+}
+
+Return<void> WifiNanIface::getCapabilitiesRequest_1_5(
+        uint16_t cmd_id, getCapabilitiesRequest_1_5_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::getCapabilitiesRequest_1_5Internal, hidl_status_cb,
+                           cmd_id);
+}
+
+Return<void> WifiNanIface::enableRequest_1_6(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
+                                             const V1_6::NanConfigRequestSupplemental& msg2,
+                                             enableRequest_1_5_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::enableRequest_1_6Internal, hidl_status_cb, cmd_id, msg1,
+                           msg2);
+}
+
+Return<void> WifiNanIface::configRequest_1_6(uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
+                                             const V1_6::NanConfigRequestSupplemental& msg2,
+                                             configRequest_1_5_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::configRequest_1_6Internal, hidl_status_cb, cmd_id, msg1,
+                           msg2);
+}
+
+Return<void> WifiNanIface::initiateDataPathRequest_1_6(uint16_t cmd_id,
+                                                       const V1_6::NanInitiateDataPathRequest& msg,
+                                                       initiateDataPathRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::initiateDataPathRequest_1_6Internal, hidl_status_cb,
+                           cmd_id, msg);
+}
+
+Return<void> WifiNanIface::respondToDataPathIndicationRequest_1_6(
+        uint16_t cmd_id, const V1_6::NanRespondToDataPathIndicationRequest& msg,
+        respondToDataPathIndicationRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::respondToDataPathIndicationRequest_1_6Internal,
+                           hidl_status_cb, cmd_id, msg);
+}
+
+Return<void> WifiNanIface::startPublishRequest_1_6(uint16_t cmd_id,
+                                                   const V1_6::NanPublishRequest& msg,
+                                                   startPublishRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::startPublishRequest_1_6Internal, hidl_status_cb, cmd_id,
+                           msg);
+}
+
+std::pair<WifiStatus, std::string> WifiNanIface::getNameInternal() {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
+}
+
+std::pair<WifiStatus, IfaceType> WifiNanIface::getTypeInternal() {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::NAN};
+}
+
+Return<void> WifiNanIface::registerEventCallback_1_6(
+        const sp<V1_6::IWifiNanIfaceEventCallback>& callback,
+        registerEventCallback_1_6_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiNanIface::registerEventCallback_1_6Internal, hidl_status_cb,
+                           callback);
+}
+
+WifiStatus WifiNanIface::registerEventCallbackInternal(
+        const sp<V1_0::IWifiNanIfaceEventCallback>& callback) {
+    if (!event_cb_handler_.addCallback(callback)) {
+        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+    }
+    return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiNanIface::getCapabilitiesRequestInternal(uint16_t /* cmd_id */) {
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiNanIface::enableRequestInternal(uint16_t /* cmd_id */,
+                                               const V1_0::NanEnableRequest& /* msg */) {
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiNanIface::configRequestInternal(uint16_t /* cmd_id */,
+                                               const V1_0::NanConfigRequest& /* msg */) {
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiNanIface::disableRequestInternal(uint16_t cmd_id) {
+    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->nanDisableRequest(ifname_, cmd_id);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiNanIface::startPublishRequestInternal(uint16_t /* cmd_id */,
+                                                     const V1_0::NanPublishRequest& /* msg */) {
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiNanIface::stopPublishRequestInternal(uint16_t cmd_id, uint8_t sessionId) {
+    legacy_hal::NanPublishCancelRequest legacy_msg;
+    legacy_msg.publish_id = sessionId;
+    legacy_hal::wifi_error legacy_status =
+            legacy_hal_.lock()->nanPublishCancelRequest(ifname_, cmd_id, legacy_msg);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiNanIface::startSubscribeRequestInternal(uint16_t cmd_id,
+                                                       const V1_0::NanSubscribeRequest& msg) {
+    legacy_hal::NanSubscribeRequest legacy_msg;
+    if (!hidl_struct_util::convertHidlNanSubscribeRequestToLegacy(msg, &legacy_msg)) {
+        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
+    }
+    legacy_hal::wifi_error legacy_status =
+            legacy_hal_.lock()->nanSubscribeRequest(ifname_, cmd_id, legacy_msg);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiNanIface::stopSubscribeRequestInternal(uint16_t cmd_id, uint8_t sessionId) {
+    legacy_hal::NanSubscribeCancelRequest legacy_msg;
+    legacy_msg.subscribe_id = sessionId;
+    legacy_hal::wifi_error legacy_status =
+            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)) {
+        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
+    }
+    legacy_hal::wifi_error legacy_status =
+            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(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(ifname_, cmd_id, iface_name);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+WifiStatus WifiNanIface::initiateDataPathRequestInternal(
+        uint16_t cmd_id, const V1_0::NanInitiateDataPathRequest& msg) {
+    legacy_hal::NanDataPathInitiatorRequest 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(ifname_, cmd_id, legacy_msg);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+WifiStatus WifiNanIface::respondToDataPathIndicationRequestInternal(
+        uint16_t cmd_id, const V1_0::NanRespondToDataPathIndicationRequest& msg) {
+    legacy_hal::NanDataPathIndicationResponse 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(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(ifname_, cmd_id, ndpInstanceId);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiNanIface::registerEventCallback_1_2Internal(
+        const sp<V1_2::IWifiNanIfaceEventCallback>& callback) {
+    sp<V1_0::IWifiNanIfaceEventCallback> callback_1_0 = callback;
+    if (!event_cb_handler_.addCallback(callback_1_0)) {
+        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+    }
+    if (!event_cb_handler_1_2_.addCallback(callback)) {
+        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+    }
+    return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiNanIface::enableRequest_1_2Internal(
+        uint16_t /* cmd_id */, const V1_0::NanEnableRequest& /* msg1 */,
+        const V1_2::NanConfigRequestSupplemental& /* msg2 */) {
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiNanIface::configRequest_1_2Internal(
+        uint16_t /* cmd_id */, const V1_0::NanConfigRequest& /* msg1 */,
+        const V1_2::NanConfigRequestSupplemental& /* msg2 */) {
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiNanIface::enableRequest_1_4Internal(
+        uint16_t /* cmd_id */, const V1_4::NanEnableRequest& /* msg1 */,
+        const V1_2::NanConfigRequestSupplemental& /* msg2 */) {
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiNanIface::configRequest_1_4Internal(
+        uint16_t /* cmd_id */, const V1_4::NanConfigRequest& /* msg1 */,
+        const V1_2::NanConfigRequestSupplemental& /* msg2 */) {
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiNanIface::registerEventCallback_1_5Internal(
+        const sp<V1_5::IWifiNanIfaceEventCallback>& callback) {
+    sp<V1_0::IWifiNanIfaceEventCallback> callback_1_0 = callback;
+    if (!event_cb_handler_.addCallback(callback_1_0)) {
+        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+    }
+    sp<V1_2::IWifiNanIfaceEventCallback> callback_1_2 = callback;
+    if (!event_cb_handler_1_2_.addCallback(callback_1_2)) {
+        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+    }
+    if (!event_cb_handler_1_5_.addCallback(callback)) {
+        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+    }
+    return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiNanIface::getCapabilitiesRequest_1_5Internal(uint16_t cmd_id) {
+    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->nanGetCapabilities(ifname_, cmd_id);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiNanIface::enableRequest_1_5Internal(
+        uint16_t /* cmd_id */, const V1_4::NanEnableRequest& /* msg1 */,
+        const V1_5::NanConfigRequestSupplemental& /* msg2 */) {
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiNanIface::configRequest_1_5Internal(
+        uint16_t /* cmd_id */, const V1_4::NanConfigRequest& /* msg1 */,
+        const V1_5::NanConfigRequestSupplemental& /* msg2 */) {
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiNanIface::enableRequest_1_6Internal(uint16_t cmd_id,
+                                                   const V1_4::NanEnableRequest& msg1,
+                                                   const V1_6::NanConfigRequestSupplemental& msg2) {
+    legacy_hal::NanEnableRequest legacy_msg;
+    if (!hidl_struct_util::convertHidlNanEnableRequest_1_6ToLegacy(msg1, msg2, &legacy_msg)) {
+        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
+    }
+    legacy_hal::wifi_error legacy_status =
+            legacy_hal_.lock()->nanEnableRequest(ifname_, cmd_id, legacy_msg);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiNanIface::configRequest_1_6Internal(uint16_t cmd_id,
+                                                   const V1_4::NanConfigRequest& msg1,
+                                                   const V1_6::NanConfigRequestSupplemental& msg2) {
+    legacy_hal::NanConfigRequest legacy_msg;
+    if (!hidl_struct_util::convertHidlNanConfigRequest_1_6ToLegacy(msg1, msg2, &legacy_msg)) {
+        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
+    }
+    legacy_hal::wifi_error legacy_status =
+            legacy_hal_.lock()->nanConfigRequest(ifname_, cmd_id, legacy_msg);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiNanIface::initiateDataPathRequest_1_6Internal(
+        uint16_t cmd_id, const V1_6::NanInitiateDataPathRequest& msg) {
+    legacy_hal::NanDataPathInitiatorRequest legacy_msg;
+    if (!hidl_struct_util::convertHidlNanDataPathInitiatorRequest_1_6ToLegacy(msg, &legacy_msg)) {
+        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
+    }
+    legacy_hal::wifi_error legacy_status =
+            legacy_hal_.lock()->nanDataRequestInitiator(ifname_, cmd_id, legacy_msg);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiNanIface::respondToDataPathIndicationRequest_1_6Internal(
+        uint16_t cmd_id, const V1_6::NanRespondToDataPathIndicationRequest& msg) {
+    legacy_hal::NanDataPathIndicationResponse legacy_msg;
+    if (!hidl_struct_util::convertHidlNanDataPathIndicationResponse_1_6ToLegacy(msg, &legacy_msg)) {
+        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
+    }
+    legacy_hal::wifi_error legacy_status =
+            legacy_hal_.lock()->nanDataIndicationResponse(ifname_, cmd_id, legacy_msg);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiNanIface::startPublishRequest_1_6Internal(uint16_t cmd_id,
+                                                         const V1_6::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(ifname_, cmd_id, legacy_msg);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiNanIface::registerEventCallback_1_6Internal(
+        const sp<V1_6::IWifiNanIfaceEventCallback>& callback) {
+    sp<V1_0::IWifiNanIfaceEventCallback> callback_1_0 = callback;
+    if (!event_cb_handler_.addCallback(callback_1_0)) {
+        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+    }
+    sp<V1_2::IWifiNanIfaceEventCallback> callback_1_2 = callback;
+    if (!event_cb_handler_1_2_.addCallback(callback_1_2)) {
+        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+    }
+    sp<V1_5::IWifiNanIfaceEventCallback> callback_1_5 = callback;
+    if (!event_cb_handler_1_5_.addCallback(callback_1_5)) {
+        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+    }
+    if (!event_cb_handler_1_6_.addCallback(callback)) {
+        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+    }
+    return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
diff --git a/wifi/1.6/default/wifi_nan_iface.h b/wifi/1.6/default/wifi_nan_iface.h
new file mode 100644
index 0000000..15bf572
--- /dev/null
+++ b/wifi/1.6/default/wifi_nan_iface.h
@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WIFI_NAN_IFACE_H_
+#define WIFI_NAN_IFACE_H_
+
+#include <android-base/macros.h>
+#include <android/hardware/wifi/1.6/IWifiNanIface.h>
+#include <android/hardware/wifi/1.6/IWifiNanIfaceEventCallback.h>
+
+#include "hidl_callback_util.h"
+#include "wifi_iface_util.h"
+#include "wifi_legacy_hal.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+using namespace android::hardware::wifi::V1_0;
+using namespace android::hardware::wifi::V1_2;
+using namespace android::hardware::wifi::V1_4;
+using namespace android::hardware::wifi::V1_6;
+
+/**
+ * HIDL interface object used to control a NAN Iface instance.
+ */
+class WifiNanIface : public V1_6::IWifiNanIface {
+  public:
+    WifiNanIface(const std::string& ifname, bool is_dedicated_iface,
+                 const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
+                 const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
+    // Refer to |WifiChip::invalidate()|.
+    void invalidate();
+    bool isValid();
+    std::string getName();
+
+    // HIDL methods exposed.
+    Return<void> getName(getName_cb hidl_status_cb) override;
+    Return<void> getType(getType_cb hidl_status_cb) override;
+    Return<void> registerEventCallback(const sp<V1_0::IWifiNanIfaceEventCallback>& callback,
+                                       registerEventCallback_cb hidl_status_cb) override;
+    Return<void> getCapabilitiesRequest(uint16_t cmd_id,
+                                        getCapabilitiesRequest_cb hidl_status_cb) override;
+    Return<void> enableRequest(uint16_t cmd_id, const V1_0::NanEnableRequest& msg,
+                               enableRequest_cb hidl_status_cb) override;
+    Return<void> configRequest(uint16_t cmd_id, const V1_0::NanConfigRequest& msg,
+                               configRequest_cb hidl_status_cb) override;
+    Return<void> disableRequest(uint16_t cmd_id, disableRequest_cb hidl_status_cb) override;
+    Return<void> startPublishRequest(uint16_t cmd_id, const V1_0::NanPublishRequest& msg,
+                                     startPublishRequest_cb hidl_status_cb) override;
+    Return<void> stopPublishRequest(uint16_t cmd_id, uint8_t sessionId,
+                                    stopPublishRequest_cb hidl_status_cb) override;
+    Return<void> startSubscribeRequest(uint16_t cmd_id, const V1_0::NanSubscribeRequest& msg,
+                                       startSubscribeRequest_cb hidl_status_cb) override;
+    Return<void> stopSubscribeRequest(uint16_t cmd_id, uint8_t sessionId,
+                                      stopSubscribeRequest_cb hidl_status_cb) override;
+    Return<void> transmitFollowupRequest(uint16_t cmd_id, const NanTransmitFollowupRequest& msg,
+                                         transmitFollowupRequest_cb hidl_status_cb) override;
+    Return<void> createDataInterfaceRequest(uint16_t cmd_id, const hidl_string& iface_name,
+                                            createDataInterfaceRequest_cb hidl_status_cb) override;
+    Return<void> deleteDataInterfaceRequest(uint16_t cmd_id, const hidl_string& iface_name,
+                                            deleteDataInterfaceRequest_cb hidl_status_cb) override;
+    Return<void> initiateDataPathRequest(uint16_t cmd_id,
+                                         const V1_0::NanInitiateDataPathRequest& msg,
+                                         initiateDataPathRequest_cb hidl_status_cb) override;
+    Return<void> respondToDataPathIndicationRequest(
+            uint16_t cmd_id, const V1_0::NanRespondToDataPathIndicationRequest& msg,
+            respondToDataPathIndicationRequest_cb hidl_status_cb) override;
+    Return<void> terminateDataPathRequest(uint16_t cmd_id, uint32_t ndpInstanceId,
+                                          terminateDataPathRequest_cb hidl_status_cb) override;
+
+    Return<void> registerEventCallback_1_2(const sp<V1_2::IWifiNanIfaceEventCallback>& callback,
+                                           registerEventCallback_1_2_cb hidl_status_cb) override;
+    Return<void> enableRequest_1_2(uint16_t cmd_id, const V1_0::NanEnableRequest& msg1,
+                                   const V1_2::NanConfigRequestSupplemental& msg2,
+                                   enableRequest_1_2_cb hidl_status_cb) override;
+    Return<void> configRequest_1_2(uint16_t cmd_id, const V1_0::NanConfigRequest& msg1,
+                                   const V1_2::NanConfigRequestSupplemental& msg2,
+                                   configRequest_1_2_cb hidl_status_cb) override;
+    Return<void> enableRequest_1_4(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
+                                   const V1_2::NanConfigRequestSupplemental& msg2,
+                                   enableRequest_1_4_cb hidl_status_cb) override;
+    Return<void> configRequest_1_4(uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
+                                   const V1_2::NanConfigRequestSupplemental& msg2,
+                                   configRequest_1_4_cb hidl_status_cb) override;
+    Return<void> registerEventCallback_1_5(const sp<V1_5::IWifiNanIfaceEventCallback>& callback,
+                                           registerEventCallback_1_5_cb hidl_status_cb) override;
+    Return<void> enableRequest_1_5(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
+                                   const V1_5::NanConfigRequestSupplemental& msg2,
+                                   enableRequest_1_5_cb hidl_status_cb) override;
+    Return<void> configRequest_1_5(uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
+                                   const V1_5::NanConfigRequestSupplemental& msg2,
+                                   configRequest_1_5_cb hidl_status_cb) override;
+    Return<void> getCapabilitiesRequest_1_5(uint16_t cmd_id,
+                                            getCapabilitiesRequest_cb hidl_status_cb) override;
+    Return<void> registerEventCallback_1_6(const sp<V1_6::IWifiNanIfaceEventCallback>& callback,
+                                           registerEventCallback_1_6_cb hidl_status_cb) override;
+    Return<void> initiateDataPathRequest_1_6(
+            uint16_t cmd_id, const V1_6::NanInitiateDataPathRequest& msg,
+            initiateDataPathRequest_1_6_cb hidl_status_cb) override;
+    Return<void> respondToDataPathIndicationRequest_1_6(
+            uint16_t cmd_id, const V1_6::NanRespondToDataPathIndicationRequest& msg,
+            respondToDataPathIndicationRequest_1_6_cb hidl_status_cb) override;
+    Return<void> enableRequest_1_6(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
+                                   const V1_6::NanConfigRequestSupplemental& msg2,
+                                   enableRequest_1_6_cb hidl_status_cb) override;
+    Return<void> configRequest_1_6(uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
+                                   const V1_6::NanConfigRequestSupplemental& msg2,
+                                   configRequest_1_6_cb hidl_status_cb) override;
+    Return<void> startPublishRequest_1_6(uint16_t cmd_id, const V1_6::NanPublishRequest& msg,
+                                         startPublishRequest_cb hidl_status_cb) override;
+
+  private:
+    // Corresponding worker functions for the HIDL methods.
+    std::pair<WifiStatus, std::string> getNameInternal();
+    std::pair<WifiStatus, IfaceType> getTypeInternal();
+    WifiStatus registerEventCallbackInternal(const sp<V1_0::IWifiNanIfaceEventCallback>& callback);
+    WifiStatus getCapabilitiesRequestInternal(uint16_t cmd_id);
+    WifiStatus enableRequestInternal(uint16_t cmd_id, const V1_0::NanEnableRequest& msg);
+    WifiStatus configRequestInternal(uint16_t cmd_id, const V1_0::NanConfigRequest& msg);
+    WifiStatus disableRequestInternal(uint16_t cmd_id);
+    WifiStatus startPublishRequestInternal(uint16_t cmd_id, const V1_0::NanPublishRequest& msg);
+    WifiStatus stopPublishRequestInternal(uint16_t cmd_id, uint8_t sessionId);
+    WifiStatus startSubscribeRequestInternal(uint16_t cmd_id, const V1_0::NanSubscribeRequest& msg);
+    WifiStatus stopSubscribeRequestInternal(uint16_t cmd_id, uint8_t sessionId);
+    WifiStatus transmitFollowupRequestInternal(uint16_t cmd_id,
+                                               const NanTransmitFollowupRequest& msg);
+    WifiStatus createDataInterfaceRequestInternal(uint16_t cmd_id, const std::string& iface_name);
+    WifiStatus deleteDataInterfaceRequestInternal(uint16_t cmd_id, const std::string& iface_name);
+    WifiStatus initiateDataPathRequestInternal(uint16_t cmd_id,
+                                               const V1_0::NanInitiateDataPathRequest& msg);
+    WifiStatus respondToDataPathIndicationRequestInternal(
+            uint16_t cmd_id, const V1_0::NanRespondToDataPathIndicationRequest& msg);
+    WifiStatus terminateDataPathRequestInternal(uint16_t cmd_id, uint32_t ndpInstanceId);
+
+    WifiStatus registerEventCallback_1_2Internal(
+            const sp<V1_2::IWifiNanIfaceEventCallback>& callback);
+    WifiStatus enableRequest_1_2Internal(uint16_t cmd_id, const V1_0::NanEnableRequest& msg1,
+                                         const V1_2::NanConfigRequestSupplemental& msg2);
+    WifiStatus configRequest_1_2Internal(uint16_t cmd_id, const V1_0::NanConfigRequest& msg,
+                                         const V1_2::NanConfigRequestSupplemental& msg2);
+    WifiStatus enableRequest_1_4Internal(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
+                                         const V1_2::NanConfigRequestSupplemental& msg2);
+    WifiStatus configRequest_1_4Internal(uint16_t cmd_id, const V1_4::NanConfigRequest& msg,
+                                         const V1_2::NanConfigRequestSupplemental& msg2);
+    WifiStatus registerEventCallback_1_5Internal(
+            const sp<V1_5::IWifiNanIfaceEventCallback>& callback);
+    WifiStatus enableRequest_1_5Internal(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
+                                         const V1_5::NanConfigRequestSupplemental& msg2);
+    WifiStatus configRequest_1_5Internal(uint16_t cmd_id, const V1_4::NanConfigRequest& msg,
+                                         const V1_5::NanConfigRequestSupplemental& msg2);
+    WifiStatus getCapabilitiesRequest_1_5Internal(uint16_t cmd_id);
+    WifiStatus registerEventCallback_1_6Internal(
+            const sp<V1_6::IWifiNanIfaceEventCallback>& callback);
+
+    WifiStatus enableRequest_1_6Internal(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
+                                         const V1_6::NanConfigRequestSupplemental& msg2);
+    WifiStatus configRequest_1_6Internal(uint16_t cmd_id, const V1_4::NanConfigRequest& msg,
+                                         const V1_6::NanConfigRequestSupplemental& msg2);
+    WifiStatus startPublishRequest_1_6Internal(uint16_t cmd_id, const V1_6::NanPublishRequest& msg);
+    WifiStatus initiateDataPathRequest_1_6Internal(uint16_t cmd_id,
+                                                   const V1_6::NanInitiateDataPathRequest& msg);
+    WifiStatus respondToDataPathIndicationRequest_1_6Internal(
+            uint16_t cmd_id, const V1_6::NanRespondToDataPathIndicationRequest& msg);
+
+    // all 1_0 and descendant callbacks
+    std::set<sp<V1_0::IWifiNanIfaceEventCallback>> getEventCallbacks();
+    // all 1_2 and descendant callbacks
+    std::set<sp<V1_2::IWifiNanIfaceEventCallback>> getEventCallbacks_1_2();
+    // all 1_5 and descendant callbacks
+    std::set<sp<V1_5::IWifiNanIfaceEventCallback>> getEventCallbacks_1_5();
+    // all 1_6 and descendant callbacks
+    std::set<sp<V1_6::IWifiNanIfaceEventCallback>> getEventCallbacks_1_6();
+
+    std::string ifname_;
+    bool is_dedicated_iface_;
+    std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
+    std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
+    bool is_valid_;
+    hidl_callback_util::HidlCallbackHandler<V1_0::IWifiNanIfaceEventCallback> event_cb_handler_;
+    hidl_callback_util::HidlCallbackHandler<V1_2::IWifiNanIfaceEventCallback> event_cb_handler_1_2_;
+    hidl_callback_util::HidlCallbackHandler<V1_5::IWifiNanIfaceEventCallback> event_cb_handler_1_5_;
+    hidl_callback_util::HidlCallbackHandler<V1_6::IWifiNanIfaceEventCallback> event_cb_handler_1_6_;
+
+    DISALLOW_COPY_AND_ASSIGN(WifiNanIface);
+};
+
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
+
+#endif  // WIFI_NAN_IFACE_H_
diff --git a/wifi/aidl/default/wifi_p2p_iface.cpp b/wifi/1.6/default/wifi_p2p_iface.cpp
similarity index 60%
rename from wifi/aidl/default/wifi_p2p_iface.cpp
rename to wifi/1.6/default/wifi_p2p_iface.cpp
index 48ec6d6..d4b1fca 100644
--- a/wifi/aidl/default/wifi_p2p_iface.cpp
+++ b/wifi/1.6/default/wifi_p2p_iface.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
-#include "wifi_p2p_iface.h"
-
 #include <android-base/logging.h>
 
-#include "aidl_return_util.h"
+#include "hidl_return_util.h"
+#include "wifi_p2p_iface.h"
 #include "wifi_status_util.h"
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
-using aidl_return_util::validateAndCall;
+namespace V1_6 {
+namespace implementation {
+using hidl_return_util::validateAndCall;
 
 WifiP2pIface::WifiP2pIface(const std::string& ifname,
                            const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
@@ -44,16 +44,26 @@
     return ifname_;
 }
 
-ndk::ScopedAStatus WifiP2pIface::getName(std::string* _aidl_return) {
+Return<void> WifiP2pIface::getName(getName_cb hidl_status_cb) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiP2pIface::getNameInternal, _aidl_return);
+                           &WifiP2pIface::getNameInternal, hidl_status_cb);
 }
 
-std::pair<std::string, ndk::ScopedAStatus> WifiP2pIface::getNameInternal() {
-    return {ifname_, ndk::ScopedAStatus::ok()};
+Return<void> WifiP2pIface::getType(getType_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiP2pIface::getTypeInternal, hidl_status_cb);
 }
 
+std::pair<WifiStatus, std::string> WifiP2pIface::getNameInternal() {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
+}
+
+std::pair<WifiStatus, IfaceType> WifiP2pIface::getTypeInternal() {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::P2P};
+}
+
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/wifi_p2p_iface.h b/wifi/1.6/default/wifi_p2p_iface.h
similarity index 64%
rename from wifi/aidl/default/wifi_p2p_iface.h
rename to wifi/1.6/default/wifi_p2p_iface.h
index d17470e..0089443 100644
--- a/wifi/aidl/default/wifi_p2p_iface.h
+++ b/wifi/1.6/default/wifi_p2p_iface.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,20 +17,22 @@
 #ifndef WIFI_P2P_IFACE_H_
 #define WIFI_P2P_IFACE_H_
 
-#include <aidl/android/hardware/wifi/BnWifiP2pIface.h>
 #include <android-base/macros.h>
+#include <android/hardware/wifi/1.0/IWifiP2pIface.h>
 
 #include "wifi_legacy_hal.h"
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
+using namespace android::hardware::wifi::V1_0;
 
 /**
- * AIDL interface object used to control a P2P Iface instance.
+ * HIDL interface object used to control a P2P Iface instance.
  */
-class WifiP2pIface : public BnWifiP2pIface {
+class WifiP2pIface : public V1_0::IWifiP2pIface {
   public:
     WifiP2pIface(const std::string& ifname,
                  const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
@@ -39,12 +41,14 @@
     bool isValid();
     std::string getName();
 
-    // AIDL methods exposed.
-    ndk::ScopedAStatus getName(std::string* _aidl_return) override;
+    // HIDL methods exposed.
+    Return<void> getName(getName_cb hidl_status_cb) override;
+    Return<void> getType(getType_cb hidl_status_cb) override;
 
   private:
-    // Corresponding worker functions for the AIDL methods.
-    std::pair<std::string, ndk::ScopedAStatus> getNameInternal();
+    // Corresponding worker functions for the HIDL methods.
+    std::pair<WifiStatus, std::string> getNameInternal();
+    std::pair<WifiStatus, IfaceType> getTypeInternal();
 
     std::string ifname_;
     std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
@@ -53,9 +57,10 @@
     DISALLOW_COPY_AND_ASSIGN(WifiP2pIface);
 };
 
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
 
 #endif  // WIFI_P2P_IFACE_H_
diff --git a/wifi/1.6/default/wifi_rtt_controller.cpp b/wifi/1.6/default/wifi_rtt_controller.cpp
new file mode 100644
index 0000000..aa9ee2f
--- /dev/null
+++ b/wifi/1.6/default/wifi_rtt_controller.cpp
@@ -0,0 +1,377 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <android-base/logging.h>
+
+#include "hidl_return_util.h"
+#include "hidl_struct_util.h"
+#include "wifi_rtt_controller.h"
+#include "wifi_status_util.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+using hidl_return_util::validateAndCall;
+
+WifiRttController::WifiRttController(const std::string& iface_name,
+                                     const sp<IWifiIface>& bound_iface,
+                                     const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
+    : ifname_(iface_name), bound_iface_(bound_iface), legacy_hal_(legacy_hal), is_valid_(true) {}
+
+void WifiRttController::invalidate() {
+    legacy_hal_.reset();
+    event_callbacks_.clear();
+    is_valid_ = false;
+}
+
+bool WifiRttController::isValid() {
+    return is_valid_;
+}
+
+std::vector<sp<V1_6::IWifiRttControllerEventCallback>> WifiRttController::getEventCallbacks() {
+    return event_callbacks_;
+}
+
+std::string WifiRttController::getIfaceName() {
+    return ifname_;
+}
+
+Return<void> WifiRttController::getBoundIface(getBoundIface_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::getBoundIfaceInternal, hidl_status_cb);
+}
+
+Return<void> WifiRttController::registerEventCallback(
+        const sp<V1_0::IWifiRttControllerEventCallback>& callback,
+        registerEventCallback_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::registerEventCallbackInternal, hidl_status_cb,
+                           callback);
+}
+
+Return<void> WifiRttController::rangeRequest(uint32_t cmd_id,
+                                             const hidl_vec<V1_0::RttConfig>& rtt_configs,
+                                             rangeRequest_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::rangeRequestInternal, hidl_status_cb, cmd_id,
+                           rtt_configs);
+}
+
+Return<void> WifiRttController::rangeCancel(uint32_t cmd_id,
+                                            const hidl_vec<hidl_array<uint8_t, 6>>& addrs,
+                                            rangeCancel_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::rangeCancelInternal, hidl_status_cb, cmd_id, addrs);
+}
+
+Return<void> WifiRttController::getCapabilities(getCapabilities_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::getCapabilitiesInternal, hidl_status_cb);
+}
+
+Return<void> WifiRttController::setLci(uint32_t cmd_id, const RttLciInformation& lci,
+                                       setLci_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::setLciInternal, hidl_status_cb, cmd_id, lci);
+}
+
+Return<void> WifiRttController::setLcr(uint32_t cmd_id, const RttLcrInformation& lcr,
+                                       setLcr_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::setLcrInternal, hidl_status_cb, cmd_id, lcr);
+}
+
+Return<void> WifiRttController::getResponderInfo(getResponderInfo_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::getResponderInfoInternal, hidl_status_cb);
+}
+
+Return<void> WifiRttController::enableResponder(uint32_t cmd_id,
+                                                const V1_0::WifiChannelInfo& channel_hint,
+                                                uint32_t max_duration_seconds,
+                                                const V1_0::RttResponder& info,
+                                                enableResponder_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::enableResponderInternal, hidl_status_cb, cmd_id,
+                           channel_hint, max_duration_seconds, info);
+}
+
+Return<void> WifiRttController::disableResponder(uint32_t cmd_id,
+                                                 disableResponder_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::disableResponderInternal, hidl_status_cb, cmd_id);
+}
+
+Return<void> WifiRttController::registerEventCallback_1_4(
+        const sp<V1_4::IWifiRttControllerEventCallback>& callback,
+        registerEventCallback_1_4_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::registerEventCallbackInternal_1_4, hidl_status_cb,
+                           callback);
+}
+
+Return<void> WifiRttController::rangeRequest_1_4(uint32_t cmd_id,
+                                                 const hidl_vec<V1_4::RttConfig>& rtt_configs,
+                                                 rangeRequest_1_4_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::rangeRequestInternal_1_4, hidl_status_cb, cmd_id,
+                           rtt_configs);
+}
+
+Return<void> WifiRttController::getCapabilities_1_4(getCapabilities_1_4_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::getCapabilitiesInternal_1_4, hidl_status_cb);
+}
+
+Return<void> WifiRttController::getResponderInfo_1_4(getResponderInfo_1_4_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::getResponderInfoInternal_1_4, hidl_status_cb);
+}
+
+Return<void> WifiRttController::enableResponder_1_4(uint32_t cmd_id,
+                                                    const V1_0::WifiChannelInfo& channel_hint,
+                                                    uint32_t max_duration_seconds,
+                                                    const V1_4::RttResponder& info,
+                                                    enableResponder_1_4_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::enableResponderInternal_1_4, hidl_status_cb, cmd_id,
+                           channel_hint, max_duration_seconds, info);
+}
+
+Return<void> WifiRttController::registerEventCallback_1_6(
+        const sp<V1_6::IWifiRttControllerEventCallback>& callback,
+        registerEventCallback_1_6_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::registerEventCallbackInternal_1_6, hidl_status_cb,
+                           callback);
+}
+
+Return<void> WifiRttController::rangeRequest_1_6(uint32_t cmd_id,
+                                                 const hidl_vec<V1_6::RttConfig>& rtt_configs,
+                                                 rangeRequest_1_6_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::rangeRequestInternal_1_6, hidl_status_cb, cmd_id,
+                           rtt_configs);
+}
+
+Return<void> WifiRttController::getCapabilities_1_6(getCapabilities_1_6_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::getCapabilitiesInternal_1_6, hidl_status_cb);
+}
+
+Return<void> WifiRttController::getResponderInfo_1_6(getResponderInfo_1_6_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::getResponderInfoInternal_1_6, hidl_status_cb);
+}
+
+Return<void> WifiRttController::enableResponder_1_6(uint32_t cmd_id,
+                                                    const V1_6::WifiChannelInfo& channel_hint,
+                                                    uint32_t max_duration_seconds,
+                                                    const V1_6::RttResponder& info,
+                                                    enableResponder_1_6_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                           &WifiRttController::enableResponderInternal_1_6, hidl_status_cb, cmd_id,
+                           channel_hint, max_duration_seconds, info);
+}
+
+std::pair<WifiStatus, sp<IWifiIface>> WifiRttController::getBoundIfaceInternal() {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), bound_iface_};
+}
+
+WifiStatus WifiRttController::registerEventCallbackInternal(
+        const sp<V1_0::IWifiRttControllerEventCallback>& /* callback */) {
+    // Deprecated support for this api
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiRttController::rangeRequestInternal(
+        uint32_t /* cmd_id */, const std::vector<V1_0::RttConfig>& /* rtt_configs */) {
+    // Deprecated support for this api
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiRttController::rangeCancelInternal(
+        uint32_t cmd_id, const std::vector<hidl_array<uint8_t, 6>>& addrs) {
+    std::vector<std::array<uint8_t, 6>> legacy_addrs;
+    for (const auto& addr : addrs) {
+        legacy_addrs.push_back(addr);
+    }
+    legacy_hal::wifi_error legacy_status =
+            legacy_hal_.lock()->cancelRttRangeRequest(ifname_, cmd_id, legacy_addrs);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+std::pair<WifiStatus, V1_0::RttCapabilities> WifiRttController::getCapabilitiesInternal() {
+    // Deprecated support for this api
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
+}
+
+WifiStatus WifiRttController::setLciInternal(uint32_t cmd_id, const RttLciInformation& lci) {
+    legacy_hal::wifi_lci_information legacy_lci;
+    if (!hidl_struct_util::convertHidlRttLciInformationToLegacy(lci, &legacy_lci)) {
+        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
+    }
+    legacy_hal::wifi_error legacy_status =
+            legacy_hal_.lock()->setRttLci(ifname_, cmd_id, legacy_lci);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiRttController::setLcrInternal(uint32_t cmd_id, const RttLcrInformation& lcr) {
+    legacy_hal::wifi_lcr_information legacy_lcr;
+    if (!hidl_struct_util::convertHidlRttLcrInformationToLegacy(lcr, &legacy_lcr)) {
+        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
+    }
+    legacy_hal::wifi_error legacy_status =
+            legacy_hal_.lock()->setRttLcr(ifname_, cmd_id, legacy_lcr);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+std::pair<WifiStatus, V1_0::RttResponder> WifiRttController::getResponderInfoInternal() {
+    // Deprecated support for this api
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
+}
+
+WifiStatus WifiRttController::enableResponderInternal(
+        uint32_t /* cmd_id */, const V1_0::WifiChannelInfo& /* channel_hint */,
+        uint32_t /* max_duration_seconds */, const V1_0::RttResponder& /* info */) {
+    // Deprecated support for this api
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED)};
+}
+
+WifiStatus WifiRttController::disableResponderInternal(uint32_t cmd_id) {
+    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->disableRttResponder(ifname_, cmd_id);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiRttController::registerEventCallbackInternal_1_4(
+        const sp<V1_4::IWifiRttControllerEventCallback>& /* callback */) {
+    // Deprecated support for this api
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiRttController::rangeRequestInternal_1_4(
+        uint32_t /* cmd_id */, const std::vector<V1_4::RttConfig>& /* rtt_configs */) {
+    // Deprecated support for this api
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+std::pair<WifiStatus, V1_4::RttCapabilities> WifiRttController::getCapabilitiesInternal_1_4() {
+    // Deprecated support for this api
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
+}
+
+std::pair<WifiStatus, V1_4::RttResponder> WifiRttController::getResponderInfoInternal_1_4() {
+    // Deprecated support for this api
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
+}
+
+WifiStatus WifiRttController::enableResponderInternal_1_4(
+        uint32_t /* cmd_id */, const V1_0::WifiChannelInfo& /* channel_hint */,
+        uint32_t /* max_duration_seconds */, const V1_4::RttResponder& /* info */) {
+    // Deprecated support for this api
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED)};
+}
+
+WifiStatus WifiRttController::registerEventCallbackInternal_1_6(
+        const sp<V1_6::IWifiRttControllerEventCallback>& callback) {
+    // TODO(b/31632518): remove the callback when the client is destroyed
+    event_callbacks_.emplace_back(callback);
+    return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiRttController::rangeRequestInternal_1_6(
+        uint32_t cmd_id, const std::vector<V1_6::RttConfig>& rtt_configs) {
+    std::vector<legacy_hal::wifi_rtt_config> legacy_configs;
+    if (!hidl_struct_util::convertHidlVectorOfRttConfigToLegacy(rtt_configs, &legacy_configs)) {
+        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
+    }
+    android::wp<WifiRttController> weak_ptr_this(this);
+    const auto& on_results_callback =
+            [weak_ptr_this](legacy_hal::wifi_request_id id,
+                            const std::vector<const legacy_hal::wifi_rtt_result*>& results) {
+                const auto shared_ptr_this = weak_ptr_this.promote();
+                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+                    LOG(ERROR) << "Callback invoked on an invalid object";
+                    return;
+                }
+                std::vector<V1_6::RttResult> hidl_results;
+                if (!hidl_struct_util::convertLegacyVectorOfRttResultToHidl(results,
+                                                                            &hidl_results)) {
+                    LOG(ERROR) << "Failed to convert rtt results to HIDL structs";
+                    return;
+                }
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->onResults_1_6(id, hidl_results).isOk()) {
+                        LOG(ERROR) << "Failed to invoke the callback";
+                    }
+                }
+            };
+    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startRttRangeRequest(
+            ifname_, cmd_id, legacy_configs, on_results_callback);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+std::pair<WifiStatus, V1_6::RttCapabilities> WifiRttController::getCapabilitiesInternal_1_6() {
+    legacy_hal::wifi_error legacy_status;
+    legacy_hal::wifi_rtt_capabilities legacy_caps;
+    std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getRttCapabilities(ifname_);
+    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
+        return {createWifiStatusFromLegacyError(legacy_status), {}};
+    }
+    V1_6::RttCapabilities hidl_caps;
+    if (!hidl_struct_util::convertLegacyRttCapabilitiesToHidl(legacy_caps, &hidl_caps)) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
+}
+
+std::pair<WifiStatus, V1_6::RttResponder> WifiRttController::getResponderInfoInternal_1_6() {
+    legacy_hal::wifi_error legacy_status;
+    legacy_hal::wifi_rtt_responder legacy_responder;
+    std::tie(legacy_status, legacy_responder) = legacy_hal_.lock()->getRttResponderInfo(ifname_);
+    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
+        return {createWifiStatusFromLegacyError(legacy_status), {}};
+    }
+    V1_6::RttResponder hidl_responder;
+    if (!hidl_struct_util::convertLegacyRttResponderToHidl(legacy_responder, &hidl_responder)) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_responder};
+}
+
+WifiStatus WifiRttController::enableResponderInternal_1_6(uint32_t cmd_id,
+                                                          const V1_6::WifiChannelInfo& channel_hint,
+                                                          uint32_t max_duration_seconds,
+                                                          const V1_6::RttResponder& info) {
+    legacy_hal::wifi_channel_info legacy_channel_info;
+    if (!hidl_struct_util::convertHidlWifiChannelInfoToLegacy(channel_hint, &legacy_channel_info)) {
+        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
+    }
+    legacy_hal::wifi_rtt_responder legacy_responder;
+    if (!hidl_struct_util::convertHidlRttResponderToLegacy(info, &legacy_responder)) {
+        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
+    }
+    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableRttResponder(
+            ifname_, cmd_id, legacy_channel_info, max_duration_seconds, legacy_responder);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
diff --git a/wifi/1.6/default/wifi_rtt_controller.h b/wifi/1.6/default/wifi_rtt_controller.h
new file mode 100644
index 0000000..fd5f68b
--- /dev/null
+++ b/wifi/1.6/default/wifi_rtt_controller.h
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WIFI_RTT_CONTROLLER_H_
+#define WIFI_RTT_CONTROLLER_H_
+
+#include <android-base/macros.h>
+#include <android/hardware/wifi/1.0/IWifiIface.h>
+#include <android/hardware/wifi/1.6/IWifiRttController.h>
+#include <android/hardware/wifi/1.6/IWifiRttControllerEventCallback.h>
+
+#include "wifi_legacy_hal.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+
+/**
+ * HIDL interface object used to control all RTT operations.
+ */
+class WifiRttController : public V1_6::IWifiRttController {
+  public:
+    WifiRttController(const std::string& iface_name, const sp<IWifiIface>& bound_iface,
+                      const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
+    // Refer to |WifiChip::invalidate()|.
+    void invalidate();
+    bool isValid();
+    std::vector<sp<V1_6::IWifiRttControllerEventCallback>> getEventCallbacks();
+    std::string getIfaceName();
+
+    // HIDL methods exposed.
+    Return<void> getBoundIface(getBoundIface_cb hidl_status_cb) override;
+    Return<void> registerEventCallback(const sp<V1_0::IWifiRttControllerEventCallback>& callback,
+                                       registerEventCallback_cb hidl_status_cb) override;
+    Return<void> rangeRequest(uint32_t cmd_id, const hidl_vec<V1_0::RttConfig>& rtt_configs,
+                              rangeRequest_cb hidl_status_cb) override;
+    Return<void> rangeCancel(uint32_t cmd_id, const hidl_vec<hidl_array<uint8_t, 6>>& addrs,
+                             rangeCancel_cb hidl_status_cb) override;
+    Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override;
+    Return<void> setLci(uint32_t cmd_id, const RttLciInformation& lci,
+                        setLci_cb hidl_status_cb) override;
+    Return<void> setLcr(uint32_t cmd_id, const RttLcrInformation& lcr,
+                        setLcr_cb hidl_status_cb) override;
+    Return<void> getResponderInfo(getResponderInfo_cb hidl_status_cb) override;
+    Return<void> enableResponder(uint32_t cmd_id, const V1_0::WifiChannelInfo& channel_hint,
+                                 uint32_t max_duration_seconds, const V1_0::RttResponder& info,
+                                 enableResponder_cb hidl_status_cb) override;
+    Return<void> disableResponder(uint32_t cmd_id, disableResponder_cb hidl_status_cb) override;
+    Return<void> registerEventCallback_1_4(
+            const sp<V1_4::IWifiRttControllerEventCallback>& callback,
+            registerEventCallback_1_4_cb hidl_status_cb) override;
+    Return<void> rangeRequest_1_4(uint32_t cmd_id, const hidl_vec<V1_4::RttConfig>& rtt_configs,
+                                  rangeRequest_1_4_cb hidl_status_cb) override;
+    Return<void> getCapabilities_1_4(getCapabilities_1_4_cb hidl_status_cb) override;
+    Return<void> getResponderInfo_1_4(getResponderInfo_1_4_cb hidl_status_cb) override;
+    Return<void> enableResponder_1_4(uint32_t cmd_id, const V1_0::WifiChannelInfo& channel_hint,
+                                     uint32_t max_duration_seconds, const V1_4::RttResponder& info,
+                                     enableResponder_1_4_cb hidl_status_cb) override;
+    Return<void> registerEventCallback_1_6(
+            const sp<V1_6::IWifiRttControllerEventCallback>& callback,
+            registerEventCallback_1_6_cb hidl_status_cb) override;
+    Return<void> rangeRequest_1_6(uint32_t cmd_id, const hidl_vec<V1_6::RttConfig>& rtt_configs,
+                                  rangeRequest_1_6_cb hidl_status_cb) override;
+    Return<void> getCapabilities_1_6(getCapabilities_1_6_cb hidl_status_cb) override;
+    Return<void> getResponderInfo_1_6(getResponderInfo_1_6_cb hidl_status_cb) override;
+    Return<void> enableResponder_1_6(uint32_t cmd_id, const V1_6::WifiChannelInfo& channel_hint,
+                                     uint32_t max_duration_seconds, const V1_6::RttResponder& info,
+                                     enableResponder_1_6_cb hidl_status_cb) override;
+
+  private:
+    // Corresponding worker functions for the HIDL methods.
+    std::pair<WifiStatus, sp<IWifiIface>> getBoundIfaceInternal();
+    WifiStatus registerEventCallbackInternal(
+            const sp<V1_0::IWifiRttControllerEventCallback>& callback);
+    WifiStatus rangeRequestInternal(uint32_t cmd_id,
+                                    const std::vector<V1_0::RttConfig>& rtt_configs);
+    WifiStatus rangeCancelInternal(uint32_t cmd_id,
+                                   const std::vector<hidl_array<uint8_t, 6>>& addrs);
+    std::pair<WifiStatus, V1_0::RttCapabilities> getCapabilitiesInternal();
+    WifiStatus setLciInternal(uint32_t cmd_id, const RttLciInformation& lci);
+    WifiStatus setLcrInternal(uint32_t cmd_id, const RttLcrInformation& lcr);
+    std::pair<WifiStatus, V1_0::RttResponder> getResponderInfoInternal();
+    WifiStatus enableResponderInternal(uint32_t cmd_id, const V1_0::WifiChannelInfo& channel_hint,
+                                       uint32_t max_duration_seconds,
+                                       const V1_0::RttResponder& info);
+    WifiStatus disableResponderInternal(uint32_t cmd_id);
+    WifiStatus registerEventCallbackInternal_1_4(
+            const sp<V1_4::IWifiRttControllerEventCallback>& callback);
+    WifiStatus rangeRequestInternal_1_4(uint32_t cmd_id,
+                                        const std::vector<V1_4::RttConfig>& rtt_configs);
+    std::pair<WifiStatus, V1_4::RttCapabilities> getCapabilitiesInternal_1_4();
+    std::pair<WifiStatus, V1_4::RttResponder> getResponderInfoInternal_1_4();
+    WifiStatus enableResponderInternal_1_4(uint32_t cmd_id,
+                                           const V1_0::WifiChannelInfo& channel_hint,
+                                           uint32_t max_duration_seconds,
+                                           const V1_4::RttResponder& info);
+    WifiStatus registerEventCallbackInternal_1_6(
+            const sp<V1_6::IWifiRttControllerEventCallback>& callback);
+    WifiStatus rangeRequestInternal_1_6(uint32_t cmd_id,
+                                        const std::vector<V1_6::RttConfig>& rtt_configs);
+    std::pair<WifiStatus, V1_6::RttCapabilities> getCapabilitiesInternal_1_6();
+    std::pair<WifiStatus, V1_6::RttResponder> getResponderInfoInternal_1_6();
+    WifiStatus enableResponderInternal_1_6(uint32_t cmd_id,
+                                           const V1_6::WifiChannelInfo& channel_hint,
+                                           uint32_t max_duration_seconds,
+                                           const V1_6::RttResponder& info);
+
+    std::string ifname_;
+    sp<IWifiIface> bound_iface_;
+    std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
+    std::vector<sp<V1_6::IWifiRttControllerEventCallback>> event_callbacks_;
+    bool is_valid_;
+
+    DISALLOW_COPY_AND_ASSIGN(WifiRttController);
+};
+
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
+
+#endif  // WIFI_RTT_CONTROLLER_H_
diff --git a/wifi/1.6/default/wifi_sta_iface.cpp b/wifi/1.6/default/wifi_sta_iface.cpp
new file mode 100644
index 0000000..dd11839
--- /dev/null
+++ b/wifi/1.6/default/wifi_sta_iface.cpp
@@ -0,0 +1,592 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <android-base/logging.h>
+
+#include "hidl_return_util.h"
+#include "hidl_struct_util.h"
+#include "wifi_sta_iface.h"
+#include "wifi_status_util.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+using hidl_return_util::validateAndCall;
+
+WifiStaIface::WifiStaIface(const std::string& ifname,
+                           const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
+                           const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
+    : ifname_(ifname), legacy_hal_(legacy_hal), iface_util_(iface_util), is_valid_(true) {
+    // Turn on DFS channel usage for STA iface.
+    legacy_hal::wifi_error legacy_status = 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.";
+    }
+}
+
+void WifiStaIface::invalidate() {
+    legacy_hal_.reset();
+    event_cb_handler_.invalidate();
+    is_valid_ = false;
+}
+
+bool WifiStaIface::isValid() {
+    return is_valid_;
+}
+
+std::string WifiStaIface::getName() {
+    return ifname_;
+}
+
+std::set<sp<IWifiStaIfaceEventCallback>> WifiStaIface::getEventCallbacks() {
+    return event_cb_handler_.getCallbacks();
+}
+
+Return<void> WifiStaIface::getName(getName_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::getNameInternal, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getType(getType_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::getTypeInternal, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::registerEventCallback(const sp<IWifiStaIfaceEventCallback>& callback,
+                                                 registerEventCallback_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::registerEventCallbackInternal, hidl_status_cb, callback);
+}
+
+Return<void> WifiStaIface::getCapabilities(getCapabilities_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::getCapabilitiesInternal, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getApfPacketFilterCapabilities(
+        getApfPacketFilterCapabilities_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::getApfPacketFilterCapabilitiesInternal, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::installApfPacketFilter(uint32_t cmd_id, const hidl_vec<uint8_t>& program,
+                                                  installApfPacketFilter_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::installApfPacketFilterInternal, hidl_status_cb, cmd_id,
+                           program);
+}
+
+Return<void> WifiStaIface::readApfPacketFilterData(readApfPacketFilterData_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::readApfPacketFilterDataInternal, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getBackgroundScanCapabilities(
+        getBackgroundScanCapabilities_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::getBackgroundScanCapabilitiesInternal, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getValidFrequenciesForBand(
+        V1_0::WifiBand band, getValidFrequenciesForBand_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::getValidFrequenciesForBandInternal, hidl_status_cb, band);
+}
+
+Return<void> WifiStaIface::startBackgroundScan(uint32_t cmd_id,
+                                               const StaBackgroundScanParameters& params,
+                                               startBackgroundScan_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::startBackgroundScanInternal, hidl_status_cb, cmd_id,
+                           params);
+}
+
+Return<void> WifiStaIface::stopBackgroundScan(uint32_t cmd_id,
+                                              stopBackgroundScan_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::stopBackgroundScanInternal, hidl_status_cb, cmd_id);
+}
+
+Return<void> WifiStaIface::enableLinkLayerStatsCollection(
+        bool debug, enableLinkLayerStatsCollection_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::enableLinkLayerStatsCollectionInternal, hidl_status_cb,
+                           debug);
+}
+
+Return<void> WifiStaIface::disableLinkLayerStatsCollection(
+        disableLinkLayerStatsCollection_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::disableLinkLayerStatsCollectionInternal, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getLinkLayerStats(getLinkLayerStats_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::getLinkLayerStatsInternal, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getLinkLayerStats_1_3(getLinkLayerStats_1_3_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::getLinkLayerStatsInternal_1_3, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getLinkLayerStats_1_5(getLinkLayerStats_1_5_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::getLinkLayerStatsInternal_1_5, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getLinkLayerStats_1_6(getLinkLayerStats_1_6_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::getLinkLayerStatsInternal_1_6, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::startRssiMonitoring(uint32_t cmd_id, int32_t max_rssi, int32_t min_rssi,
+                                               startRssiMonitoring_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::startRssiMonitoringInternal, hidl_status_cb, cmd_id,
+                           max_rssi, min_rssi);
+}
+
+Return<void> WifiStaIface::stopRssiMonitoring(uint32_t cmd_id,
+                                              stopRssiMonitoring_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::stopRssiMonitoringInternal, hidl_status_cb, cmd_id);
+}
+
+Return<void> WifiStaIface::getRoamingCapabilities(getRoamingCapabilities_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::getRoamingCapabilitiesInternal, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::configureRoaming(const StaRoamingConfig& config,
+                                            configureRoaming_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::configureRoamingInternal, hidl_status_cb, config);
+}
+
+Return<void> WifiStaIface::setRoamingState(StaRoamingState state,
+                                           setRoamingState_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::setRoamingStateInternal, hidl_status_cb, state);
+}
+
+Return<void> WifiStaIface::enableNdOffload(bool enable, enableNdOffload_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::enableNdOffloadInternal, hidl_status_cb, enable);
+}
+
+Return<void> WifiStaIface::startSendingKeepAlivePackets(
+        uint32_t cmd_id, const hidl_vec<uint8_t>& ip_packet_data, uint16_t ether_type,
+        const hidl_array<uint8_t, 6>& src_address, const hidl_array<uint8_t, 6>& dst_address,
+        uint32_t period_in_ms, startSendingKeepAlivePackets_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::startSendingKeepAlivePacketsInternal, hidl_status_cb,
+                           cmd_id, ip_packet_data, ether_type, src_address, dst_address,
+                           period_in_ms);
+}
+
+Return<void> WifiStaIface::stopSendingKeepAlivePackets(
+        uint32_t cmd_id, stopSendingKeepAlivePackets_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::stopSendingKeepAlivePacketsInternal, hidl_status_cb,
+                           cmd_id);
+}
+
+Return<void> WifiStaIface::setScanningMacOui(const hidl_array<uint8_t, 3>& oui,
+                                             setScanningMacOui_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::setScanningMacOuiInternal, hidl_status_cb, oui);
+}
+
+Return<void> WifiStaIface::startDebugPacketFateMonitoring(
+        startDebugPacketFateMonitoring_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::startDebugPacketFateMonitoringInternal, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getDebugTxPacketFates(getDebugTxPacketFates_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::getDebugTxPacketFatesInternal, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getDebugRxPacketFates(getDebugRxPacketFates_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::getDebugRxPacketFatesInternal, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::setMacAddress(const hidl_array<uint8_t, 6>& mac,
+                                         setMacAddress_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::setMacAddressInternal, hidl_status_cb, mac);
+}
+
+Return<void> WifiStaIface::getFactoryMacAddress(getFactoryMacAddress_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::getFactoryMacAddressInternal, hidl_status_cb);
+}
+
+Return<void> WifiStaIface::setScanMode(bool enable, setScanMode_cb hidl_status_cb) {
+    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                           &WifiStaIface::setScanModeInternal, hidl_status_cb, enable);
+}
+
+std::pair<WifiStatus, std::string> WifiStaIface::getNameInternal() {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
+}
+
+std::pair<WifiStatus, IfaceType> WifiStaIface::getTypeInternal() {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::STA};
+}
+
+WifiStatus WifiStaIface::registerEventCallbackInternal(
+        const sp<IWifiStaIfaceEventCallback>& callback) {
+    if (!event_cb_handler_.addCallback(callback)) {
+        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+    }
+    return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, uint32_t> WifiStaIface::getCapabilitiesInternal() {
+    legacy_hal::wifi_error legacy_status;
+    uint64_t legacy_feature_set;
+    std::tie(legacy_status, legacy_feature_set) =
+            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(ifname_);
+    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
+        // some devices don't support querying logger feature set
+        legacy_logger_feature_set = 0;
+    }
+    uint32_t hidl_caps;
+    if (!hidl_struct_util::convertLegacyFeaturesToHidlStaCapabilities(
+                legacy_feature_set, legacy_logger_feature_set, &hidl_caps)) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), 0};
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
+}
+
+std::pair<WifiStatus, StaApfPacketFilterCapabilities>
+WifiStaIface::getApfPacketFilterCapabilitiesInternal() {
+    legacy_hal::wifi_error legacy_status;
+    legacy_hal::PacketFilterCapabilities legacy_caps;
+    std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getPacketFilterCapabilities(ifname_);
+    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
+        return {createWifiStatusFromLegacyError(legacy_status), {}};
+    }
+    StaApfPacketFilterCapabilities hidl_caps;
+    if (!hidl_struct_util::convertLegacyApfCapabilitiesToHidl(legacy_caps, &hidl_caps)) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
+}
+
+WifiStatus WifiStaIface::installApfPacketFilterInternal(uint32_t /* cmd_id */,
+                                                        const std::vector<uint8_t>& program) {
+    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setPacketFilter(ifname_, program);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+std::pair<WifiStatus, std::vector<uint8_t>> WifiStaIface::readApfPacketFilterDataInternal() {
+    const std::pair<legacy_hal::wifi_error, std::vector<uint8_t>> legacy_status_and_data =
+            legacy_hal_.lock()->readApfPacketFilterData(ifname_);
+    return {createWifiStatusFromLegacyError(legacy_status_and_data.first),
+            std::move(legacy_status_and_data.second)};
+}
+
+std::pair<WifiStatus, StaBackgroundScanCapabilities>
+WifiStaIface::getBackgroundScanCapabilitiesInternal() {
+    legacy_hal::wifi_error legacy_status;
+    legacy_hal::wifi_gscan_capabilities legacy_caps;
+    std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getGscanCapabilities(ifname_);
+    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
+        return {createWifiStatusFromLegacyError(legacy_status), {}};
+    }
+    StaBackgroundScanCapabilities hidl_caps;
+    if (!hidl_struct_util::convertLegacyGscanCapabilitiesToHidl(legacy_caps, &hidl_caps)) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
+}
+
+std::pair<WifiStatus, std::vector<WifiChannelInMhz>>
+WifiStaIface::getValidFrequenciesForBandInternal(V1_0::WifiBand band) {
+    static_assert(sizeof(WifiChannelInMhz) == sizeof(uint32_t), "Size mismatch");
+    legacy_hal::wifi_error legacy_status;
+    std::vector<uint32_t> valid_frequencies;
+    std::tie(legacy_status, valid_frequencies) = legacy_hal_.lock()->getValidFrequenciesForBand(
+            ifname_, hidl_struct_util::convertHidlWifiBandToLegacy(band));
+    return {createWifiStatusFromLegacyError(legacy_status), valid_frequencies};
+}
+
+WifiStatus WifiStaIface::startBackgroundScanInternal(uint32_t cmd_id,
+                                                     const StaBackgroundScanParameters& params) {
+    legacy_hal::wifi_scan_cmd_params legacy_params;
+    if (!hidl_struct_util::convertHidlGscanParamsToLegacy(params, &legacy_params)) {
+        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
+    }
+    android::wp<WifiStaIface> weak_ptr_this(this);
+    const auto& on_failure_callback = [weak_ptr_this](legacy_hal::wifi_request_id id) {
+        const auto shared_ptr_this = weak_ptr_this.promote();
+        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+            LOG(ERROR) << "Callback invoked on an invalid object";
+            return;
+        }
+        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+            if (!callback->onBackgroundScanFailure(id).isOk()) {
+                LOG(ERROR) << "Failed to invoke onBackgroundScanFailure callback";
+            }
+        }
+    };
+    const auto& on_results_callback =
+            [weak_ptr_this](legacy_hal::wifi_request_id id,
+                            const std::vector<legacy_hal::wifi_cached_scan_results>& results) {
+                const auto shared_ptr_this = weak_ptr_this.promote();
+                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+                    LOG(ERROR) << "Callback invoked on an invalid object";
+                    return;
+                }
+                std::vector<StaScanData> hidl_scan_datas;
+                if (!hidl_struct_util::convertLegacyVectorOfCachedGscanResultsToHidl(
+                            results, &hidl_scan_datas)) {
+                    LOG(ERROR) << "Failed to convert scan results to HIDL structs";
+                    return;
+                }
+                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+                    if (!callback->onBackgroundScanResults(id, hidl_scan_datas).isOk()) {
+                        LOG(ERROR) << "Failed to invoke onBackgroundScanResults callback";
+                    }
+                }
+            };
+    const auto& on_full_result_callback = [weak_ptr_this](
+                                                  legacy_hal::wifi_request_id id,
+                                                  const legacy_hal::wifi_scan_result* result,
+                                                  uint32_t buckets_scanned) {
+        const auto shared_ptr_this = weak_ptr_this.promote();
+        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+            LOG(ERROR) << "Callback invoked on an invalid object";
+            return;
+        }
+        StaScanResult hidl_scan_result;
+        if (!hidl_struct_util::convertLegacyGscanResultToHidl(*result, true, &hidl_scan_result)) {
+            LOG(ERROR) << "Failed to convert full scan results to HIDL structs";
+            return;
+        }
+        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+            if (!callback->onBackgroundFullScanResult(id, buckets_scanned, hidl_scan_result)
+                         .isOk()) {
+                LOG(ERROR) << "Failed to invoke onBackgroundFullScanResult callback";
+            }
+        }
+    };
+    legacy_hal::wifi_error legacy_status =
+            legacy_hal_.lock()->startGscan(ifname_, cmd_id, legacy_params, on_failure_callback,
+                                           on_results_callback, on_full_result_callback);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiStaIface::stopBackgroundScanInternal(uint32_t 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(ifname_, debug);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiStaIface::disableLinkLayerStatsCollectionInternal() {
+    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->disableLinkLayerStats(ifname_);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+std::pair<WifiStatus, V1_0::StaLinkLayerStats> WifiStaIface::getLinkLayerStatsInternal() {
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
+}
+
+std::pair<WifiStatus, V1_3::StaLinkLayerStats> WifiStaIface::getLinkLayerStatsInternal_1_3() {
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
+}
+
+std::pair<WifiStatus, V1_5::StaLinkLayerStats> WifiStaIface::getLinkLayerStatsInternal_1_5() {
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
+}
+
+std::pair<WifiStatus, V1_6::StaLinkLayerStats> WifiStaIface::getLinkLayerStatsInternal_1_6() {
+    legacy_hal::wifi_error legacy_status;
+    legacy_hal::LinkLayerStats legacy_stats;
+    std::tie(legacy_status, legacy_stats) = legacy_hal_.lock()->getLinkLayerStats(ifname_);
+    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
+        return {createWifiStatusFromLegacyError(legacy_status), {}};
+    }
+    V1_6::StaLinkLayerStats hidl_stats;
+    if (!hidl_struct_util::convertLegacyLinkLayerStatsToHidl(legacy_stats, &hidl_stats)) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_stats};
+}
+
+WifiStatus WifiStaIface::startRssiMonitoringInternal(uint32_t cmd_id, int32_t max_rssi,
+                                                     int32_t min_rssi) {
+    android::wp<WifiStaIface> weak_ptr_this(this);
+    const auto& on_threshold_breached_callback = [weak_ptr_this](legacy_hal::wifi_request_id id,
+                                                                 std::array<uint8_t, 6> bssid,
+                                                                 int8_t rssi) {
+        const auto shared_ptr_this = weak_ptr_this.promote();
+        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+            LOG(ERROR) << "Callback invoked on an invalid object";
+            return;
+        }
+        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+            if (!callback->onRssiThresholdBreached(id, bssid, rssi).isOk()) {
+                LOG(ERROR) << "Failed to invoke onRssiThresholdBreached callback";
+            }
+        }
+    };
+    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startRssiMonitoring(
+            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(ifname_, cmd_id);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+std::pair<WifiStatus, StaRoamingCapabilities> WifiStaIface::getRoamingCapabilitiesInternal() {
+    legacy_hal::wifi_error legacy_status;
+    legacy_hal::wifi_roaming_capabilities legacy_caps;
+    std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getRoamingCapabilities(ifname_);
+    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
+        return {createWifiStatusFromLegacyError(legacy_status), {}};
+    }
+    StaRoamingCapabilities hidl_caps;
+    if (!hidl_struct_util::convertLegacyRoamingCapabilitiesToHidl(legacy_caps, &hidl_caps)) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
+}
+
+WifiStatus WifiStaIface::configureRoamingInternal(const StaRoamingConfig& config) {
+    legacy_hal::wifi_roaming_config legacy_config;
+    if (!hidl_struct_util::convertHidlRoamingConfigToLegacy(config, &legacy_config)) {
+        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
+    }
+    legacy_hal::wifi_error legacy_status =
+            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(
+            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(ifname_, enable);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiStaIface::startSendingKeepAlivePacketsInternal(
+        uint32_t cmd_id, const std::vector<uint8_t>& ip_packet_data, uint16_t ether_type,
+        const std::array<uint8_t, 6>& src_address, const std::array<uint8_t, 6>& dst_address,
+        uint32_t period_in_ms) {
+    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startSendingOffloadedPacket(
+            ifname_, cmd_id, ether_type, 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(ifname_, cmd_id);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+WifiStatus WifiStaIface::setScanningMacOuiInternal(const std::array<uint8_t, 3>& /* oui */) {
+    // deprecated.
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+WifiStatus WifiStaIface::startDebugPacketFateMonitoringInternal() {
+    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startPktFateMonitoring(ifname_);
+    return createWifiStatusFromLegacyError(legacy_status);
+}
+
+std::pair<WifiStatus, std::vector<WifiDebugTxPacketFateReport>>
+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(ifname_);
+    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
+        return {createWifiStatusFromLegacyError(legacy_status), {}};
+    }
+    std::vector<WifiDebugTxPacketFateReport> hidl_fates;
+    if (!hidl_struct_util::convertLegacyVectorOfDebugTxPacketFateToHidl(legacy_fates,
+                                                                        &hidl_fates)) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_fates};
+}
+
+std::pair<WifiStatus, std::vector<WifiDebugRxPacketFateReport>>
+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(ifname_);
+    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
+        return {createWifiStatusFromLegacyError(legacy_status), {}};
+    }
+    std::vector<WifiDebugRxPacketFateReport> hidl_fates;
+    if (!hidl_struct_util::convertLegacyVectorOfDebugRxPacketFateToHidl(legacy_fates,
+                                                                        &hidl_fates)) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_fates};
+}
+
+WifiStatus WifiStaIface::setMacAddressInternal(const std::array<uint8_t, 6>& mac) {
+    bool status = iface_util_.lock()->setMacAddress(ifname_, mac);
+    if (!status) {
+        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
+    }
+    return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, std::array<uint8_t, 6>> WifiStaIface::getFactoryMacAddressInternal() {
+    std::array<uint8_t, 6> mac = iface_util_.lock()->getFactoryMacAddress(ifname_);
+    if (mac[0] == 0 && mac[1] == 0 && mac[2] == 0 && mac[3] == 0 && mac[4] == 0 && mac[5] == 0) {
+        return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), mac};
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), mac};
+}
+
+WifiStatus WifiStaIface::setScanModeInternal(bool enable) {
+    // OEM's need to implement this on their devices if needed.
+    LOG(WARNING) << "setScanModeInternal(" << enable << ") not supported";
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
+}
+
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
diff --git a/wifi/1.6/default/wifi_sta_iface.h b/wifi/1.6/default/wifi_sta_iface.h
new file mode 100644
index 0000000..c01c50b
--- /dev/null
+++ b/wifi/1.6/default/wifi_sta_iface.h
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WIFI_STA_IFACE_H_
+#define WIFI_STA_IFACE_H_
+
+#include <android-base/macros.h>
+#include <android/hardware/wifi/1.0/IWifiStaIfaceEventCallback.h>
+#include <android/hardware/wifi/1.6/IWifiStaIface.h>
+
+#include "hidl_callback_util.h"
+#include "wifi_iface_util.h"
+#include "wifi_legacy_hal.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+using namespace android::hardware::wifi::V1_0;
+
+/**
+ * HIDL interface object used to control a STA Iface instance.
+ */
+class WifiStaIface : public V1_6::IWifiStaIface {
+  public:
+    WifiStaIface(const std::string& ifname,
+                 const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
+                 const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
+    // Refer to |WifiChip::invalidate()|.
+    void invalidate();
+    bool isValid();
+    std::set<sp<IWifiStaIfaceEventCallback>> getEventCallbacks();
+    std::string getName();
+
+    // HIDL methods exposed.
+    Return<void> getName(getName_cb hidl_status_cb) override;
+    Return<void> getType(getType_cb hidl_status_cb) override;
+    Return<void> registerEventCallback(const sp<IWifiStaIfaceEventCallback>& callback,
+                                       registerEventCallback_cb hidl_status_cb) override;
+    Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override;
+    Return<void> getApfPacketFilterCapabilities(
+            getApfPacketFilterCapabilities_cb hidl_status_cb) override;
+    Return<void> installApfPacketFilter(uint32_t cmd_id, const hidl_vec<uint8_t>& program,
+                                        installApfPacketFilter_cb hidl_status_cb) override;
+    Return<void> readApfPacketFilterData(readApfPacketFilterData_cb hidl_status_cb) override;
+    Return<void> getBackgroundScanCapabilities(
+            getBackgroundScanCapabilities_cb hidl_status_cb) override;
+    Return<void> getValidFrequenciesForBand(V1_0::WifiBand band,
+                                            getValidFrequenciesForBand_cb hidl_status_cb) override;
+    Return<void> startBackgroundScan(uint32_t cmd_id, const StaBackgroundScanParameters& params,
+                                     startBackgroundScan_cb hidl_status_cb) override;
+    Return<void> stopBackgroundScan(uint32_t cmd_id, stopBackgroundScan_cb hidl_status_cb) override;
+    Return<void> enableLinkLayerStatsCollection(
+            bool debug, enableLinkLayerStatsCollection_cb hidl_status_cb) override;
+    Return<void> disableLinkLayerStatsCollection(
+            disableLinkLayerStatsCollection_cb hidl_status_cb) override;
+    Return<void> getLinkLayerStats(getLinkLayerStats_cb hidl_status_cb) override;
+    Return<void> getLinkLayerStats_1_3(getLinkLayerStats_1_3_cb hidl_status_cb) override;
+    Return<void> getLinkLayerStats_1_5(getLinkLayerStats_1_5_cb hidl_status_cb) override;
+    Return<void> getLinkLayerStats_1_6(getLinkLayerStats_1_6_cb hidl_status_cb) override;
+    Return<void> startRssiMonitoring(uint32_t cmd_id, int32_t max_rssi, int32_t min_rssi,
+                                     startRssiMonitoring_cb hidl_status_cb) override;
+    Return<void> stopRssiMonitoring(uint32_t cmd_id, stopRssiMonitoring_cb hidl_status_cb) override;
+    Return<void> getRoamingCapabilities(getRoamingCapabilities_cb hidl_status_cb) override;
+    Return<void> configureRoaming(const StaRoamingConfig& config,
+                                  configureRoaming_cb hidl_status_cb) override;
+    Return<void> setRoamingState(StaRoamingState state, setRoamingState_cb hidl_status_cb) override;
+    Return<void> enableNdOffload(bool enable, enableNdOffload_cb hidl_status_cb) override;
+    Return<void> startSendingKeepAlivePackets(
+            uint32_t cmd_id, const hidl_vec<uint8_t>& ip_packet_data, uint16_t ether_type,
+            const hidl_array<uint8_t, 6>& src_address, const hidl_array<uint8_t, 6>& dst_address,
+            uint32_t period_in_ms, startSendingKeepAlivePackets_cb hidl_status_cb) override;
+    Return<void> stopSendingKeepAlivePackets(
+            uint32_t cmd_id, stopSendingKeepAlivePackets_cb hidl_status_cb) override;
+    Return<void> setScanningMacOui(const hidl_array<uint8_t, 3>& oui,
+                                   setScanningMacOui_cb hidl_status_cb) override;
+    Return<void> startDebugPacketFateMonitoring(
+            startDebugPacketFateMonitoring_cb hidl_status_cb) override;
+    Return<void> getDebugTxPacketFates(getDebugTxPacketFates_cb hidl_status_cb) override;
+    Return<void> getDebugRxPacketFates(getDebugRxPacketFates_cb hidl_status_cb) override;
+    Return<void> setMacAddress(const hidl_array<uint8_t, 6>& mac,
+                               setMacAddress_cb hidl_status_cb) override;
+    Return<void> getFactoryMacAddress(getFactoryMacAddress_cb hidl_status_cb) override;
+    Return<void> setScanMode(bool enable, setScanMode_cb hidl_status_cb) override;
+
+  private:
+    // Corresponding worker functions for the HIDL methods.
+    std::pair<WifiStatus, std::string> getNameInternal();
+    std::pair<WifiStatus, IfaceType> getTypeInternal();
+    WifiStatus registerEventCallbackInternal(const sp<IWifiStaIfaceEventCallback>& callback);
+    std::pair<WifiStatus, uint32_t> getCapabilitiesInternal();
+    std::pair<WifiStatus, StaApfPacketFilterCapabilities> getApfPacketFilterCapabilitiesInternal();
+    WifiStatus installApfPacketFilterInternal(uint32_t cmd_id, const std::vector<uint8_t>& program);
+    std::pair<WifiStatus, std::vector<uint8_t>> readApfPacketFilterDataInternal();
+    std::pair<WifiStatus, StaBackgroundScanCapabilities> getBackgroundScanCapabilitiesInternal();
+    std::pair<WifiStatus, std::vector<WifiChannelInMhz>> getValidFrequenciesForBandInternal(
+            V1_0::WifiBand band);
+    WifiStatus startBackgroundScanInternal(uint32_t cmd_id,
+                                           const StaBackgroundScanParameters& params);
+    WifiStatus stopBackgroundScanInternal(uint32_t cmd_id);
+    WifiStatus enableLinkLayerStatsCollectionInternal(bool debug);
+    WifiStatus disableLinkLayerStatsCollectionInternal();
+    std::pair<WifiStatus, V1_0::StaLinkLayerStats> getLinkLayerStatsInternal();
+    std::pair<WifiStatus, V1_3::StaLinkLayerStats> getLinkLayerStatsInternal_1_3();
+    std::pair<WifiStatus, V1_5::StaLinkLayerStats> getLinkLayerStatsInternal_1_5();
+    std::pair<WifiStatus, V1_6::StaLinkLayerStats> getLinkLayerStatsInternal_1_6();
+    WifiStatus startRssiMonitoringInternal(uint32_t cmd_id, int32_t max_rssi, int32_t min_rssi);
+    WifiStatus stopRssiMonitoringInternal(uint32_t cmd_id);
+    std::pair<WifiStatus, StaRoamingCapabilities> getRoamingCapabilitiesInternal();
+    WifiStatus configureRoamingInternal(const StaRoamingConfig& config);
+    WifiStatus setRoamingStateInternal(StaRoamingState state);
+    WifiStatus enableNdOffloadInternal(bool enable);
+    WifiStatus startSendingKeepAlivePacketsInternal(uint32_t cmd_id,
+                                                    const std::vector<uint8_t>& ip_packet_data,
+                                                    uint16_t ether_type,
+                                                    const std::array<uint8_t, 6>& src_address,
+                                                    const std::array<uint8_t, 6>& dst_address,
+                                                    uint32_t period_in_ms);
+    WifiStatus stopSendingKeepAlivePacketsInternal(uint32_t cmd_id);
+    WifiStatus setScanningMacOuiInternal(const std::array<uint8_t, 3>& oui);
+    WifiStatus startDebugPacketFateMonitoringInternal();
+    std::pair<WifiStatus, std::vector<WifiDebugTxPacketFateReport>> getDebugTxPacketFatesInternal();
+    std::pair<WifiStatus, std::vector<WifiDebugRxPacketFateReport>> getDebugRxPacketFatesInternal();
+    WifiStatus setMacAddressInternal(const std::array<uint8_t, 6>& mac);
+    std::pair<WifiStatus, std::array<uint8_t, 6>> getFactoryMacAddressInternal();
+    WifiStatus setScanModeInternal(bool enable);
+
+    std::string ifname_;
+    std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
+    std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
+    bool is_valid_;
+    hidl_callback_util::HidlCallbackHandler<IWifiStaIfaceEventCallback> event_cb_handler_;
+
+    DISALLOW_COPY_AND_ASSIGN(WifiStaIface);
+};
+
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
+
+#endif  // WIFI_STA_IFACE_H_
diff --git a/wifi/aidl/default/wifi_status_util.cpp b/wifi/1.6/default/wifi_status_util.cpp
similarity index 79%
rename from wifi/aidl/default/wifi_status_util.cpp
rename to wifi/1.6/default/wifi_status_util.cpp
index 25ecd71..3b18e53 100644
--- a/wifi/aidl/default/wifi_status_util.cpp
+++ b/wifi/1.6/default/wifi_status_util.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,10 +16,11 @@
 
 #include "wifi_status_util.h"
 
-namespace aidl {
 namespace android {
 namespace hardware {
 namespace wifi {
+namespace V1_6 {
+namespace implementation {
 
 std::string legacyErrorToString(legacy_hal::wifi_error error) {
     switch (error) {
@@ -50,21 +51,16 @@
     }
 }
 
-ndk::ScopedAStatus createWifiStatus(WifiStatusCode code, const std::string& description) {
-    return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(static_cast<int32_t>(code),
-                                                                   description.c_str());
+WifiStatus createWifiStatus(WifiStatusCode code, const std::string& description) {
+    return {code, description};
 }
 
-ndk::ScopedAStatus createWifiStatus(WifiStatusCode code) {
-    return ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(code));
+WifiStatus createWifiStatus(WifiStatusCode code) {
+    return createWifiStatus(code, "");
 }
 
-ndk::ScopedAStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error,
-                                                   const std::string& desc) {
+WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error, const std::string& desc) {
     switch (error) {
-        case legacy_hal::WIFI_ERROR_NONE:
-            return ndk::ScopedAStatus::ok();
-
         case legacy_hal::WIFI_ERROR_UNINITIALIZED:
         case legacy_hal::WIFI_ERROR_NOT_AVAILABLE:
             return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE, desc);
@@ -88,6 +84,9 @@
         case legacy_hal::WIFI_ERROR_BUSY:
             return createWifiStatus(WifiStatusCode::ERROR_BUSY);
 
+        case legacy_hal::WIFI_ERROR_NONE:
+            return createWifiStatus(WifiStatusCode::SUCCESS, desc);
+
         case legacy_hal::WIFI_ERROR_UNKNOWN:
             return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, "unknown");
 
@@ -96,11 +95,12 @@
     }
 }
 
-ndk::ScopedAStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error) {
+WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error) {
     return createWifiStatusFromLegacyError(error, "");
 }
 
+}  // namespace implementation
+}  // namespace V1_6
 }  // namespace wifi
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
diff --git a/wifi/1.6/default/wifi_status_util.h b/wifi/1.6/default/wifi_status_util.h
new file mode 100644
index 0000000..ea1c294
--- /dev/null
+++ b/wifi/1.6/default/wifi_status_util.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WIFI_STATUS_UTIL_H_
+#define WIFI_STATUS_UTIL_H_
+
+#include <android/hardware/wifi/1.4/IWifi.h>
+
+#include "wifi_legacy_hal.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_6 {
+namespace implementation {
+using namespace android::hardware::wifi::V1_0;
+
+std::string legacyErrorToString(legacy_hal::wifi_error error);
+WifiStatus createWifiStatus(WifiStatusCode code, const std::string& description);
+WifiStatus createWifiStatus(WifiStatusCode code);
+WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error,
+                                           const std::string& description);
+WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error);
+
+}  // namespace implementation
+}  // namespace V1_6
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
+
+#endif  // WIFI_STATUS_UTIL_H_
diff --git a/wifi/aidl/default/aidl_callback_util.h b/wifi/aidl/default/aidl_callback_util.h
deleted file mode 100644
index 41d70a5..0000000
--- a/wifi/aidl/default/aidl_callback_util.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef AIDL_CALLBACK_UTIL_H_
-#define AIDL_CALLBACK_UTIL_H_
-
-#include <android-base/logging.h>
-
-#include <set>
-#include <unordered_map>
-
-namespace {
-std::unordered_map<void* /* callback */, void* /* handler */> callback_handler_map_;
-}
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-namespace aidl_callback_util {
-
-// Provides a class to manage callbacks for the various AIDL interfaces and
-// handle the death of the process hosting each callback.
-template <typename CallbackType>
-class AidlCallbackHandler {
-  public:
-    AidlCallbackHandler() {
-        death_handler_ = AIBinder_DeathRecipient_new(AidlCallbackHandler::onCallbackDeath);
-    }
-    ~AidlCallbackHandler() { invalidate(); }
-
-    bool addCallback(const std::shared_ptr<CallbackType>& cb) {
-        void* cbPtr = reinterpret_cast<void*>(cb->asBinder().get());
-        const auto& cbPosition = findCbInSet(cbPtr);
-        if (cbPosition != cb_set_.end()) {
-            LOG(WARNING) << "Duplicate death notification registration";
-            return true;
-        }
-
-        if (AIBinder_linkToDeath(cb->asBinder().get(), death_handler_, cbPtr /* cookie */) !=
-            STATUS_OK) {
-            LOG(ERROR) << "Failed to register death notification";
-            return false;
-        }
-
-        callback_handler_map_[cbPtr] = reinterpret_cast<void*>(this);
-        cb_set_.insert(cb);
-        return true;
-    }
-
-    const std::set<std::shared_ptr<CallbackType>>& getCallbacks() { return cb_set_; }
-
-    void invalidate() {
-        for (auto cb : cb_set_) {
-            void* cookie = reinterpret_cast<void*>(cb->asBinder().get());
-            if (AIBinder_unlinkToDeath(cb->asBinder().get(), death_handler_, cookie) != STATUS_OK) {
-                LOG(ERROR) << "Failed to deregister death notification";
-            }
-            if (!removeCbFromHandlerMap(cookie)) {
-                LOG(ERROR) << "Failed to remove callback from handler map";
-            }
-        }
-        cb_set_.clear();
-    }
-
-    // Entry point for the death handling logic. AIBinder_DeathRecipient
-    // can only call a static function, so use the cookie to find the
-    // proper handler and route the request there.
-    static void onCallbackDeath(void* cookie) {
-        auto cbQuery = callback_handler_map_.find(cookie);
-        if (cbQuery == callback_handler_map_.end()) {
-            LOG(ERROR) << "Invalid death cookie received";
-            return;
-        }
-
-        AidlCallbackHandler* cbHandler = reinterpret_cast<AidlCallbackHandler*>(cbQuery->second);
-        if (cbHandler == nullptr) {
-            LOG(ERROR) << "Handler mapping contained an invalid handler";
-            return;
-        }
-        cbHandler->handleCallbackDeath(cbQuery->first);
-    }
-
-  private:
-    std::set<std::shared_ptr<CallbackType>> cb_set_;
-    AIBinder_DeathRecipient* death_handler_;
-
-    typename std::set<std::shared_ptr<CallbackType>>::iterator findCbInSet(void* cbPtr) {
-        const auto& cbPosition = std::find_if(
-                cb_set_.begin(), cb_set_.end(), [cbPtr](const std::shared_ptr<CallbackType>& p) {
-                    return cbPtr == reinterpret_cast<void*>(p->asBinder().get());
-                });
-        return cbPosition;
-    }
-
-    bool removeCbFromHandlerMap(void* cbPtr) {
-        auto cbQuery = callback_handler_map_.find(cbPtr);
-        if (cbQuery != callback_handler_map_.end()) {
-            callback_handler_map_.erase(cbQuery);
-            return true;
-        }
-        return false;
-    }
-
-    void handleCallbackDeath(void* cbPtr) {
-        const auto& cbPosition = findCbInSet(cbPtr);
-        if (cbPosition == cb_set_.end()) {
-            LOG(ERROR) << "Unknown callback death notification received";
-            return;
-        }
-        cb_set_.erase(cbPosition);
-
-        if (!removeCbFromHandlerMap(cbPtr)) {
-            LOG(ERROR) << "Callback was not in callback handler map";
-        }
-    }
-
-    DISALLOW_COPY_AND_ASSIGN(AidlCallbackHandler);
-};
-
-}  // namespace aidl_callback_util
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
-
-#endif  // AIDL_CALLBACK_UTIL_H_
diff --git a/wifi/aidl/default/aidl_return_util.h b/wifi/aidl/default/aidl_return_util.h
deleted file mode 100644
index 9a49a22..0000000
--- a/wifi/aidl/default/aidl_return_util.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef AIDL_RETURN_UTIL_H_
-#define AIDL_RETURN_UTIL_H_
-
-#include "aidl_sync_util.h"
-#include "wifi_status_util.h"
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-namespace aidl_return_util {
-using aidl::android::hardware::wifi::WifiStatusCode;
-using aidl::android::hardware::wifi::aidl_sync_util::acquireGlobalLock;
-
-/**
- * These utility functions are used to invoke a method on the provided
- * AIDL interface object.
- * These functions checks if the provided AIDL interface object is valid.
- * a) If valid, Invokes the corresponding internal implementation function of
- * the AIDL method.
- * b) If invalid, return without calling the internal implementation function.
- */
-
-// Use for AIDL methods which return only an AIDL status.
-template <typename ObjT, typename WorkFuncT, typename... Args>
-::ndk::ScopedAStatus validateAndCall(ObjT* obj, WifiStatusCode status_code_if_invalid,
-                                     WorkFuncT&& work, Args&&... args) {
-    const auto lock = acquireGlobalLock();
-    if (obj->isValid()) {
-        return (obj->*work)(std::forward<Args>(args)...);
-    } else {
-        return createWifiStatus(status_code_if_invalid);
-    }
-}
-
-// Use for AIDL methods which return only an AIDL status.
-// This version passes the global lock acquired to the body of the method.
-template <typename ObjT, typename WorkFuncT, typename... Args>
-::ndk::ScopedAStatus validateAndCallWithLock(ObjT* obj, WifiStatusCode status_code_if_invalid,
-                                             WorkFuncT&& work, Args&&... args) {
-    auto lock = acquireGlobalLock();
-    if (obj->isValid()) {
-        return (obj->*work)(&lock, std::forward<Args>(args)...);
-    } else {
-        return createWifiStatus(status_code_if_invalid);
-    }
-}
-
-// Use for AIDL methods which have a return value along with the AIDL status
-template <typename ObjT, typename WorkFuncT, typename ReturnT, typename... Args>
-::ndk::ScopedAStatus validateAndCall(ObjT* obj, WifiStatusCode status_code_if_invalid,
-                                     WorkFuncT&& work, ReturnT* ret_val, Args&&... args) {
-    const auto lock = acquireGlobalLock();
-    if (obj->isValid()) {
-        auto call_pair = (obj->*work)(std::forward<Args>(args)...);
-        *ret_val = call_pair.first;
-        return std::forward<::ndk::ScopedAStatus>(call_pair.second);
-    } else {
-        return ndk::ScopedAStatus::fromServiceSpecificError(
-                static_cast<int32_t>(status_code_if_invalid));
-    }
-}
-
-}  // namespace aidl_return_util
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
-#endif  // AIDL_RETURN_UTIL_H_
diff --git a/wifi/aidl/default/aidl_struct_util.cpp b/wifi/aidl/default/aidl_struct_util.cpp
deleted file mode 100644
index 07612b6..0000000
--- a/wifi/aidl/default/aidl_struct_util.cpp
+++ /dev/null
@@ -1,2775 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <android-base/logging.h>
-#include <utils/SystemClock.h>
-
-#include "aidl_struct_util.h"
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-namespace aidl_struct_util {
-
-WifiChannelWidthInMhz convertLegacyWifiChannelWidthToAidl(legacy_hal::wifi_channel_width type);
-
-std::string safeConvertChar(const char* str, size_t max_len) {
-    const char* c = str;
-    size_t size = 0;
-    while (*c && (unsigned char)*c < 128 && size < max_len) {
-        ++size;
-        ++c;
-    }
-    return std::string(str, size);
-}
-
-inline std::vector<int32_t> uintToIntVec(const std::vector<uint32_t>& in) {
-    return std::vector<int32_t>(in.begin(), in.end());
-}
-
-IWifiChip::ChipCapabilityMask convertLegacyLoggerFeatureToAidlChipCapability(uint32_t feature) {
-    switch (feature) {
-        case legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED:
-            return IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_FIRMWARE_DUMP;
-        case legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED:
-            return IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_DRIVER_DUMP;
-        case legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED:
-            return IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_CONNECT_EVENT;
-        case legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED:
-            return IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_POWER_EVENT;
-        case legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED:
-            return IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_WAKELOCK_EVENT;
-    };
-    CHECK(false) << "Unknown legacy feature: " << feature;
-    return {};
-}
-
-IWifiStaIface::StaIfaceCapabilityMask convertLegacyLoggerFeatureToAidlStaIfaceCapability(
-        uint32_t feature) {
-    switch (feature) {
-        case legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED:
-            return IWifiStaIface::StaIfaceCapabilityMask::DEBUG_PACKET_FATE;
-    };
-    CHECK(false) << "Unknown legacy feature: " << feature;
-    return {};
-}
-
-IWifiChip::ChipCapabilityMask convertLegacyFeatureToAidlChipCapability(uint64_t feature) {
-    switch (feature) {
-        case WIFI_FEATURE_SET_TX_POWER_LIMIT:
-            return IWifiChip::ChipCapabilityMask::SET_TX_POWER_LIMIT;
-        case WIFI_FEATURE_USE_BODY_HEAD_SAR:
-            return IWifiChip::ChipCapabilityMask::USE_BODY_HEAD_SAR;
-        case WIFI_FEATURE_D2D_RTT:
-            return IWifiChip::ChipCapabilityMask::D2D_RTT;
-        case WIFI_FEATURE_D2AP_RTT:
-            return IWifiChip::ChipCapabilityMask::D2AP_RTT;
-        case WIFI_FEATURE_INFRA_60G:
-            return IWifiChip::ChipCapabilityMask::WIGIG;
-        case WIFI_FEATURE_SET_LATENCY_MODE:
-            return IWifiChip::ChipCapabilityMask::SET_LATENCY_MODE;
-        case WIFI_FEATURE_P2P_RAND_MAC:
-            return IWifiChip::ChipCapabilityMask::P2P_RAND_MAC;
-    };
-    CHECK(false) << "Unknown legacy feature: " << feature;
-    return {};
-}
-
-IWifiStaIface::StaIfaceCapabilityMask convertLegacyFeatureToAidlStaIfaceCapability(
-        uint64_t feature) {
-    switch (feature) {
-        case WIFI_FEATURE_GSCAN:
-            return IWifiStaIface::StaIfaceCapabilityMask::BACKGROUND_SCAN;
-        case WIFI_FEATURE_LINK_LAYER_STATS:
-            return IWifiStaIface::StaIfaceCapabilityMask::LINK_LAYER_STATS;
-        case WIFI_FEATURE_RSSI_MONITOR:
-            return IWifiStaIface::StaIfaceCapabilityMask::RSSI_MONITOR;
-        case WIFI_FEATURE_CONTROL_ROAMING:
-            return IWifiStaIface::StaIfaceCapabilityMask::CONTROL_ROAMING;
-        case WIFI_FEATURE_IE_WHITELIST:
-            return IWifiStaIface::StaIfaceCapabilityMask::PROBE_IE_ALLOWLIST;
-        case WIFI_FEATURE_SCAN_RAND:
-            return IWifiStaIface::StaIfaceCapabilityMask::SCAN_RAND;
-        case WIFI_FEATURE_INFRA_5G:
-            return IWifiStaIface::StaIfaceCapabilityMask::STA_5G;
-        case WIFI_FEATURE_HOTSPOT:
-            return IWifiStaIface::StaIfaceCapabilityMask::HOTSPOT;
-        case WIFI_FEATURE_PNO:
-            return IWifiStaIface::StaIfaceCapabilityMask::PNO;
-        case WIFI_FEATURE_TDLS:
-            return IWifiStaIface::StaIfaceCapabilityMask::TDLS;
-        case WIFI_FEATURE_TDLS_OFFCHANNEL:
-            return IWifiStaIface::StaIfaceCapabilityMask::TDLS_OFFCHANNEL;
-        case WIFI_FEATURE_CONFIG_NDO:
-            return IWifiStaIface::StaIfaceCapabilityMask::ND_OFFLOAD;
-        case WIFI_FEATURE_MKEEP_ALIVE:
-            return IWifiStaIface::StaIfaceCapabilityMask::KEEP_ALIVE;
-    };
-    CHECK(false) << "Unknown legacy feature: " << feature;
-    return {};
-}
-
-bool convertLegacyFeaturesToAidlChipCapabilities(uint64_t legacy_feature_set,
-                                                 uint32_t legacy_logger_feature_set,
-                                                 uint32_t* aidl_caps) {
-    if (!aidl_caps) {
-        return false;
-    }
-    *aidl_caps = {};
-    for (const auto feature : {legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED,
-                               legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED,
-                               legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED,
-                               legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED,
-                               legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED}) {
-        if (feature & legacy_logger_feature_set) {
-            *aidl_caps |=
-                    static_cast<uint32_t>(convertLegacyLoggerFeatureToAidlChipCapability(feature));
-        }
-    }
-    std::vector<uint64_t> features = {WIFI_FEATURE_SET_TX_POWER_LIMIT,
-                                      WIFI_FEATURE_USE_BODY_HEAD_SAR,
-                                      WIFI_FEATURE_D2D_RTT,
-                                      WIFI_FEATURE_D2AP_RTT,
-                                      WIFI_FEATURE_INFRA_60G,
-                                      WIFI_FEATURE_SET_LATENCY_MODE,
-                                      WIFI_FEATURE_P2P_RAND_MAC};
-    for (const auto feature : features) {
-        if (feature & legacy_feature_set) {
-            *aidl_caps |= static_cast<uint32_t>(convertLegacyFeatureToAidlChipCapability(feature));
-        }
-    }
-
-    // There are no flags for these 3 in the legacy feature set. Adding them to
-    // the set because all the current devices support it.
-    *aidl_caps |=
-            static_cast<uint32_t>(IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_VENDOR_DATA);
-    *aidl_caps |=
-            static_cast<uint32_t>(IWifiChip::ChipCapabilityMask::DEBUG_HOST_WAKE_REASON_STATS);
-    *aidl_caps |= static_cast<uint32_t>(IWifiChip::ChipCapabilityMask::DEBUG_ERROR_ALERTS);
-    return true;
-}
-
-WifiDebugRingBufferFlags convertLegacyDebugRingBufferFlagsToAidl(uint32_t flag) {
-    switch (flag) {
-        case WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES:
-            return WifiDebugRingBufferFlags::HAS_BINARY_ENTRIES;
-        case WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES:
-            return WifiDebugRingBufferFlags::HAS_ASCII_ENTRIES;
-    };
-    CHECK(false) << "Unknown legacy flag: " << flag;
-    return {};
-}
-
-bool convertLegacyDebugRingBufferStatusToAidl(
-        const legacy_hal::wifi_ring_buffer_status& legacy_status,
-        WifiDebugRingBufferStatus* aidl_status) {
-    if (!aidl_status) {
-        return false;
-    }
-    *aidl_status = {};
-    aidl_status->ringName = safeConvertChar(reinterpret_cast<const char*>(legacy_status.name),
-                                            sizeof(legacy_status.name));
-    aidl_status->flags = 0;
-    for (const auto flag :
-         {WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES, WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES}) {
-        if (flag & legacy_status.flags) {
-            aidl_status->flags |= static_cast<std::underlying_type<WifiDebugRingBufferFlags>::type>(
-                    convertLegacyDebugRingBufferFlagsToAidl(flag));
-        }
-    }
-    aidl_status->ringId = legacy_status.ring_id;
-    aidl_status->sizeInBytes = legacy_status.ring_buffer_byte_size;
-    // Calculate free size of the ring the buffer. We don't need to send the
-    // exact read/write pointers that were there in the legacy HAL interface.
-    if (legacy_status.written_bytes >= legacy_status.read_bytes) {
-        aidl_status->freeSizeInBytes = legacy_status.ring_buffer_byte_size -
-                                       (legacy_status.written_bytes - legacy_status.read_bytes);
-    } else {
-        aidl_status->freeSizeInBytes = legacy_status.read_bytes - legacy_status.written_bytes;
-    }
-    aidl_status->verboseLevel = legacy_status.verbose_level;
-    return true;
-}
-
-bool convertLegacyVectorOfDebugRingBufferStatusToAidl(
-        const std::vector<legacy_hal::wifi_ring_buffer_status>& legacy_status_vec,
-        std::vector<WifiDebugRingBufferStatus>* aidl_status_vec) {
-    if (!aidl_status_vec) {
-        return false;
-    }
-    *aidl_status_vec = {};
-    for (const auto& legacy_status : legacy_status_vec) {
-        WifiDebugRingBufferStatus aidl_status;
-        if (!convertLegacyDebugRingBufferStatusToAidl(legacy_status, &aidl_status)) {
-            return false;
-        }
-        aidl_status_vec->push_back(aidl_status);
-    }
-    return true;
-}
-
-bool convertLegacyWakeReasonStatsToAidl(const legacy_hal::WakeReasonStats& legacy_stats,
-                                        WifiDebugHostWakeReasonStats* aidl_stats) {
-    if (!aidl_stats) {
-        return false;
-    }
-    *aidl_stats = {};
-    aidl_stats->totalCmdEventWakeCnt = legacy_stats.wake_reason_cnt.total_cmd_event_wake;
-    aidl_stats->cmdEventWakeCntPerType = uintToIntVec(legacy_stats.cmd_event_wake_cnt);
-    aidl_stats->totalDriverFwLocalWakeCnt = legacy_stats.wake_reason_cnt.total_driver_fw_local_wake;
-    aidl_stats->driverFwLocalWakeCntPerType = uintToIntVec(legacy_stats.driver_fw_local_wake_cnt);
-    aidl_stats->totalRxPacketWakeCnt = legacy_stats.wake_reason_cnt.total_rx_data_wake;
-    aidl_stats->rxPktWakeDetails.rxUnicastCnt =
-            legacy_stats.wake_reason_cnt.rx_wake_details.rx_unicast_cnt;
-    aidl_stats->rxPktWakeDetails.rxMulticastCnt =
-            legacy_stats.wake_reason_cnt.rx_wake_details.rx_multicast_cnt;
-    aidl_stats->rxPktWakeDetails.rxBroadcastCnt =
-            legacy_stats.wake_reason_cnt.rx_wake_details.rx_broadcast_cnt;
-    aidl_stats->rxMulticastPkWakeDetails.ipv4RxMulticastAddrCnt =
-            legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info.ipv4_rx_multicast_addr_cnt;
-    aidl_stats->rxMulticastPkWakeDetails.ipv6RxMulticastAddrCnt =
-            legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info.ipv6_rx_multicast_addr_cnt;
-    aidl_stats->rxMulticastPkWakeDetails.otherRxMulticastAddrCnt =
-            legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info.other_rx_multicast_addr_cnt;
-    aidl_stats->rxIcmpPkWakeDetails.icmpPkt =
-            legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp_pkt;
-    aidl_stats->rxIcmpPkWakeDetails.icmp6Pkt =
-            legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_pkt;
-    aidl_stats->rxIcmpPkWakeDetails.icmp6Ra =
-            legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ra;
-    aidl_stats->rxIcmpPkWakeDetails.icmp6Na =
-            legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_na;
-    aidl_stats->rxIcmpPkWakeDetails.icmp6Ns =
-            legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ns;
-    return true;
-}
-
-legacy_hal::wifi_power_scenario convertAidlTxPowerScenarioToLegacy(
-        IWifiChip::TxPowerScenario aidl_scenario) {
-    switch (aidl_scenario) {
-        case IWifiChip::TxPowerScenario::VOICE_CALL:
-            return legacy_hal::WIFI_POWER_SCENARIO_VOICE_CALL;
-        case IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF:
-            return legacy_hal::WIFI_POWER_SCENARIO_ON_HEAD_CELL_OFF;
-        case IWifiChip::TxPowerScenario::ON_HEAD_CELL_ON:
-            return legacy_hal::WIFI_POWER_SCENARIO_ON_HEAD_CELL_ON;
-        case IWifiChip::TxPowerScenario::ON_BODY_CELL_OFF:
-            return legacy_hal::WIFI_POWER_SCENARIO_ON_BODY_CELL_OFF;
-        case IWifiChip::TxPowerScenario::ON_BODY_CELL_ON:
-            return legacy_hal::WIFI_POWER_SCENARIO_ON_BODY_CELL_ON;
-    };
-    CHECK(false);
-}
-
-legacy_hal::wifi_latency_mode convertAidlLatencyModeToLegacy(
-        IWifiChip::LatencyMode aidl_latency_mode) {
-    switch (aidl_latency_mode) {
-        case IWifiChip::LatencyMode::NORMAL:
-            return legacy_hal::WIFI_LATENCY_MODE_NORMAL;
-        case IWifiChip::LatencyMode::LOW:
-            return legacy_hal::WIFI_LATENCY_MODE_LOW;
-    }
-    CHECK(false);
-}
-
-bool convertLegacyWifiMacInfoToAidl(const legacy_hal::WifiMacInfo& legacy_mac_info,
-                                    IWifiChipEventCallback::RadioModeInfo* aidl_radio_mode_info) {
-    if (!aidl_radio_mode_info) {
-        return false;
-    }
-    *aidl_radio_mode_info = {};
-
-    aidl_radio_mode_info->radioId = legacy_mac_info.wlan_mac_id;
-    // Convert from bitmask of bands in the legacy HAL to enum value in
-    // the AIDL interface.
-    if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND &&
-        legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND &&
-        legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND) {
-        aidl_radio_mode_info->bandInfo = WifiBand::BAND_24GHZ_5GHZ_6GHZ;
-    } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND &&
-               legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
-        aidl_radio_mode_info->bandInfo = WifiBand::BAND_5GHZ_6GHZ;
-    } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND) {
-        aidl_radio_mode_info->bandInfo = WifiBand::BAND_6GHZ;
-    } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND &&
-               legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
-        aidl_radio_mode_info->bandInfo = WifiBand::BAND_24GHZ_5GHZ;
-    } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND) {
-        aidl_radio_mode_info->bandInfo = WifiBand::BAND_24GHZ;
-    } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
-        aidl_radio_mode_info->bandInfo = WifiBand::BAND_5GHZ;
-    } else {
-        aidl_radio_mode_info->bandInfo = WifiBand::BAND_UNSPECIFIED;
-    }
-    std::vector<IWifiChipEventCallback::IfaceInfo> iface_info_vec;
-    for (const auto& legacy_iface_info : legacy_mac_info.iface_infos) {
-        IWifiChipEventCallback::IfaceInfo iface_info;
-        iface_info.name = legacy_iface_info.name;
-        iface_info.channel = legacy_iface_info.channel;
-        iface_info_vec.push_back(iface_info);
-    }
-    aidl_radio_mode_info->ifaceInfos = iface_info_vec;
-    return true;
-}
-
-uint32_t convertAidlWifiBandToLegacyMacBand(WifiBand aidl_band) {
-    switch (aidl_band) {
-        case WifiBand::BAND_24GHZ:
-            return legacy_hal::WLAN_MAC_2_4_BAND;
-        case WifiBand::BAND_5GHZ:
-        case WifiBand::BAND_5GHZ_DFS:
-        case WifiBand::BAND_5GHZ_WITH_DFS:
-            return legacy_hal::WLAN_MAC_5_0_BAND;
-        case WifiBand::BAND_24GHZ_5GHZ:
-        case WifiBand::BAND_24GHZ_5GHZ_WITH_DFS:
-            return (legacy_hal::WLAN_MAC_2_4_BAND | legacy_hal::WLAN_MAC_5_0_BAND);
-        case WifiBand::BAND_6GHZ:
-            return legacy_hal::WLAN_MAC_6_0_BAND;
-        case WifiBand::BAND_5GHZ_6GHZ:
-            return (legacy_hal::WLAN_MAC_5_0_BAND | legacy_hal::WLAN_MAC_6_0_BAND);
-        case WifiBand::BAND_24GHZ_5GHZ_6GHZ:
-        case WifiBand::BAND_24GHZ_5GHZ_WITH_DFS_6GHZ:
-            return (legacy_hal::WLAN_MAC_2_4_BAND | legacy_hal::WLAN_MAC_5_0_BAND |
-                    legacy_hal::WLAN_MAC_6_0_BAND);
-        case WifiBand::BAND_60GHZ:
-            return legacy_hal::WLAN_MAC_60_0_BAND;
-        default:
-            return (legacy_hal::WLAN_MAC_2_4_BAND | legacy_hal::WLAN_MAC_5_0_BAND |
-                    legacy_hal::WLAN_MAC_6_0_BAND | legacy_hal::WLAN_MAC_60_0_BAND);
-    }
-}
-
-WifiBand convertLegacyMacBandToAidlWifiBand(uint32_t band) {
-    switch (band) {
-        case legacy_hal::WLAN_MAC_2_4_BAND:
-            return WifiBand::BAND_24GHZ;
-        case legacy_hal::WLAN_MAC_5_0_BAND:
-            return WifiBand::BAND_5GHZ;
-        case legacy_hal::WLAN_MAC_6_0_BAND:
-            return WifiBand::BAND_6GHZ;
-        case legacy_hal::WLAN_MAC_60_0_BAND:
-            return WifiBand::BAND_60GHZ;
-        default:
-            return WifiBand::BAND_UNSPECIFIED;
-    }
-}
-
-uint32_t convertAidlWifiIfaceModeToLegacy(uint32_t aidl_iface_mask) {
-    uint32_t legacy_iface_mask = 0;
-    if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_STA)) {
-        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_STA);
-    }
-    if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_SOFTAP)) {
-        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_SOFTAP);
-    }
-    if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_P2P_CLIENT)) {
-        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_P2P_CLIENT);
-    }
-    if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_P2P_GO)) {
-        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_P2P_GO);
-    }
-    if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_NAN)) {
-        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_NAN);
-    }
-    if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_TDLS)) {
-        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_TDLS);
-    }
-    if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_MESH)) {
-        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_MESH);
-    }
-    if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_IBSS)) {
-        legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_IBSS);
-    }
-    return legacy_iface_mask;
-}
-
-uint32_t convertLegacyWifiInterfaceModeToAidl(uint32_t legacy_iface_mask) {
-    uint32_t aidl_iface_mask = 0;
-    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_STA)) {
-        aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_STA);
-    }
-    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_SOFTAP)) {
-        aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_SOFTAP);
-    }
-    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_P2P_CLIENT)) {
-        aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_P2P_CLIENT);
-    }
-    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_P2P_GO)) {
-        aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_P2P_GO);
-    }
-    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_NAN)) {
-        aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_NAN);
-    }
-    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_TDLS)) {
-        aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_TDLS);
-    }
-    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_MESH)) {
-        aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_MESH);
-    }
-    if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_IBSS)) {
-        aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_IBSS);
-    }
-    return aidl_iface_mask;
-}
-
-uint32_t convertAidlUsableChannelFilterToLegacy(uint32_t aidl_filter_mask) {
-    uint32_t legacy_filter_mask = 0;
-    if (aidl_filter_mask &
-        static_cast<int32_t>(IWifiChip::UsableChannelFilter::CELLULAR_COEXISTENCE)) {
-        legacy_filter_mask |= legacy_hal::WIFI_USABLE_CHANNEL_FILTER_CELLULAR_COEXISTENCE;
-    }
-    if (aidl_filter_mask & static_cast<int32_t>(IWifiChip::UsableChannelFilter::CONCURRENCY)) {
-        legacy_filter_mask |= legacy_hal::WIFI_USABLE_CHANNEL_FILTER_CONCURRENCY;
-    }
-    if (aidl_filter_mask & static_cast<int32_t>(IWifiChip::UsableChannelFilter::NAN_INSTANT_MODE)) {
-        legacy_filter_mask |= WIFI_USABLE_CHANNEL_FILTER_NAN_INSTANT_MODE;
-    }
-    return legacy_filter_mask;
-}
-
-bool convertLegacyWifiUsableChannelToAidl(
-        const legacy_hal::wifi_usable_channel& legacy_usable_channel,
-        WifiUsableChannel* aidl_usable_channel) {
-    if (!aidl_usable_channel) {
-        return false;
-    }
-    *aidl_usable_channel = {};
-    aidl_usable_channel->channel = legacy_usable_channel.freq;
-    aidl_usable_channel->channelBandwidth =
-            convertLegacyWifiChannelWidthToAidl(legacy_usable_channel.width);
-    aidl_usable_channel->ifaceModeMask = static_cast<WifiIfaceMode>(
-            convertLegacyWifiInterfaceModeToAidl(legacy_usable_channel.iface_mode_mask));
-
-    return true;
-}
-
-bool convertLegacyWifiUsableChannelsToAidl(
-        const std::vector<legacy_hal::wifi_usable_channel>& legacy_usable_channels,
-        std::vector<WifiUsableChannel>* aidl_usable_channels) {
-    if (!aidl_usable_channels) {
-        return false;
-    }
-    *aidl_usable_channels = {};
-    for (const auto& legacy_usable_channel : legacy_usable_channels) {
-        WifiUsableChannel aidl_usable_channel;
-        if (!convertLegacyWifiUsableChannelToAidl(legacy_usable_channel, &aidl_usable_channel)) {
-            return false;
-        }
-        aidl_usable_channels->push_back(aidl_usable_channel);
-    }
-    return true;
-}
-
-bool convertLegacyWifiMacInfosToAidl(
-        const std::vector<legacy_hal::WifiMacInfo>& legacy_mac_infos,
-        std::vector<IWifiChipEventCallback::RadioModeInfo>* aidl_radio_mode_infos) {
-    if (!aidl_radio_mode_infos) {
-        return false;
-    }
-    *aidl_radio_mode_infos = {};
-
-    for (const auto& legacy_mac_info : legacy_mac_infos) {
-        IWifiChipEventCallback::RadioModeInfo aidl_radio_mode_info;
-        if (!convertLegacyWifiMacInfoToAidl(legacy_mac_info, &aidl_radio_mode_info)) {
-            return false;
-        }
-        aidl_radio_mode_infos->push_back(aidl_radio_mode_info);
-    }
-    return true;
-}
-
-bool convertLegacyFeaturesToAidlStaCapabilities(uint64_t legacy_feature_set,
-                                                uint32_t legacy_logger_feature_set,
-                                                uint32_t* aidl_caps) {
-    if (!aidl_caps) {
-        return false;
-    }
-    *aidl_caps = {};
-    for (const auto feature : {legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED}) {
-        if (feature & legacy_logger_feature_set) {
-            *aidl_caps |= static_cast<uint32_t>(
-                    convertLegacyLoggerFeatureToAidlStaIfaceCapability(feature));
-        }
-    }
-    for (const auto feature :
-         {WIFI_FEATURE_GSCAN, WIFI_FEATURE_LINK_LAYER_STATS, WIFI_FEATURE_RSSI_MONITOR,
-          WIFI_FEATURE_CONTROL_ROAMING, WIFI_FEATURE_IE_WHITELIST, WIFI_FEATURE_SCAN_RAND,
-          WIFI_FEATURE_INFRA_5G, WIFI_FEATURE_HOTSPOT, WIFI_FEATURE_PNO, WIFI_FEATURE_TDLS,
-          WIFI_FEATURE_TDLS_OFFCHANNEL, WIFI_FEATURE_CONFIG_NDO, WIFI_FEATURE_MKEEP_ALIVE}) {
-        if (feature & legacy_feature_set) {
-            *aidl_caps |=
-                    static_cast<uint32_t>(convertLegacyFeatureToAidlStaIfaceCapability(feature));
-        }
-    }
-    // There is no flag for this one in the legacy feature set. Adding it to the
-    // set because all the current devices support it.
-    *aidl_caps |= static_cast<uint32_t>(IWifiStaIface::StaIfaceCapabilityMask::APF);
-    return true;
-}
-
-bool convertLegacyApfCapabilitiesToAidl(const legacy_hal::PacketFilterCapabilities& legacy_caps,
-                                        StaApfPacketFilterCapabilities* aidl_caps) {
-    if (!aidl_caps) {
-        return false;
-    }
-    *aidl_caps = {};
-    aidl_caps->version = legacy_caps.version;
-    aidl_caps->maxLength = legacy_caps.max_len;
-    return true;
-}
-
-uint8_t convertAidlGscanReportEventFlagToLegacy(
-        StaBackgroundScanBucketEventReportSchemeMask aidl_flag) {
-    using AidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
-    switch (aidl_flag) {
-        case AidlFlag::EACH_SCAN:
-            return REPORT_EVENTS_EACH_SCAN;
-        case AidlFlag::FULL_RESULTS:
-            return REPORT_EVENTS_FULL_RESULTS;
-        case AidlFlag::NO_BATCH:
-            return REPORT_EVENTS_NO_BATCH;
-    };
-    CHECK(false);
-}
-
-StaScanDataFlagMask convertLegacyGscanDataFlagToAidl(uint8_t legacy_flag) {
-    switch (legacy_flag) {
-        case legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED:
-            return StaScanDataFlagMask::INTERRUPTED;
-    };
-    CHECK(false) << "Unknown legacy flag: " << legacy_flag;
-    // To silence the compiler warning about reaching the end of non-void
-    // function.
-    return {};
-}
-
-bool convertLegacyGscanCapabilitiesToAidl(const legacy_hal::wifi_gscan_capabilities& legacy_caps,
-                                          StaBackgroundScanCapabilities* aidl_caps) {
-    if (!aidl_caps) {
-        return false;
-    }
-    *aidl_caps = {};
-    aidl_caps->maxCacheSize = legacy_caps.max_scan_cache_size;
-    aidl_caps->maxBuckets = legacy_caps.max_scan_buckets;
-    aidl_caps->maxApCachePerScan = legacy_caps.max_ap_cache_per_scan;
-    aidl_caps->maxReportingThreshold = legacy_caps.max_scan_reporting_threshold;
-    return true;
-}
-
-legacy_hal::wifi_band convertAidlWifiBandToLegacy(WifiBand band) {
-    switch (band) {
-        case WifiBand::BAND_UNSPECIFIED:
-            return legacy_hal::WIFI_BAND_UNSPECIFIED;
-        case WifiBand::BAND_24GHZ:
-            return legacy_hal::WIFI_BAND_BG;
-        case WifiBand::BAND_5GHZ:
-            return legacy_hal::WIFI_BAND_A;
-        case WifiBand::BAND_5GHZ_DFS:
-            return legacy_hal::WIFI_BAND_A_DFS;
-        case WifiBand::BAND_5GHZ_WITH_DFS:
-            return legacy_hal::WIFI_BAND_A_WITH_DFS;
-        case WifiBand::BAND_24GHZ_5GHZ:
-            return legacy_hal::WIFI_BAND_ABG;
-        case WifiBand::BAND_24GHZ_5GHZ_WITH_DFS:
-            return legacy_hal::WIFI_BAND_ABG_WITH_DFS;
-        default:
-            CHECK(false);
-            return {};
-    };
-}
-
-bool convertAidlGscanParamsToLegacy(const StaBackgroundScanParameters& aidl_scan_params,
-                                    legacy_hal::wifi_scan_cmd_params* legacy_scan_params) {
-    if (!legacy_scan_params) {
-        return false;
-    }
-    *legacy_scan_params = {};
-    legacy_scan_params->base_period = aidl_scan_params.basePeriodInMs;
-    legacy_scan_params->max_ap_per_scan = aidl_scan_params.maxApPerScan;
-    legacy_scan_params->report_threshold_percent = aidl_scan_params.reportThresholdPercent;
-    legacy_scan_params->report_threshold_num_scans = aidl_scan_params.reportThresholdNumScans;
-    if (aidl_scan_params.buckets.size() > MAX_BUCKETS) {
-        return false;
-    }
-    legacy_scan_params->num_buckets = aidl_scan_params.buckets.size();
-    for (uint32_t bucket_idx = 0; bucket_idx < aidl_scan_params.buckets.size(); bucket_idx++) {
-        const StaBackgroundScanBucketParameters& aidl_bucket_spec =
-                aidl_scan_params.buckets[bucket_idx];
-        legacy_hal::wifi_scan_bucket_spec& legacy_bucket_spec =
-                legacy_scan_params->buckets[bucket_idx];
-        if (aidl_bucket_spec.bucketIdx >= MAX_BUCKETS) {
-            return false;
-        }
-        legacy_bucket_spec.bucket = aidl_bucket_spec.bucketIdx;
-        legacy_bucket_spec.band = convertAidlWifiBandToLegacy(aidl_bucket_spec.band);
-        legacy_bucket_spec.period = aidl_bucket_spec.periodInMs;
-        legacy_bucket_spec.max_period = aidl_bucket_spec.exponentialMaxPeriodInMs;
-        legacy_bucket_spec.base = aidl_bucket_spec.exponentialBase;
-        legacy_bucket_spec.step_count = aidl_bucket_spec.exponentialStepCount;
-        legacy_bucket_spec.report_events = 0;
-        using AidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
-        for (const auto flag : {AidlFlag::EACH_SCAN, AidlFlag::FULL_RESULTS, AidlFlag::NO_BATCH}) {
-            if (static_cast<int32_t>(aidl_bucket_spec.eventReportScheme) &
-                static_cast<std::underlying_type<AidlFlag>::type>(flag)) {
-                legacy_bucket_spec.report_events |= convertAidlGscanReportEventFlagToLegacy(flag);
-            }
-        }
-        if (aidl_bucket_spec.frequencies.size() > MAX_CHANNELS) {
-            return false;
-        }
-        legacy_bucket_spec.num_channels = aidl_bucket_spec.frequencies.size();
-        for (uint32_t freq_idx = 0; freq_idx < aidl_bucket_spec.frequencies.size(); freq_idx++) {
-            legacy_bucket_spec.channels[freq_idx].channel = aidl_bucket_spec.frequencies[freq_idx];
-        }
-    }
-    return true;
-}
-
-bool convertLegacyIeToAidl(const legacy_hal::wifi_information_element& legacy_ie,
-                           WifiInformationElement* aidl_ie) {
-    if (!aidl_ie) {
-        return false;
-    }
-    *aidl_ie = {};
-    aidl_ie->id = legacy_ie.id;
-    aidl_ie->data = std::vector<uint8_t>(legacy_ie.data, legacy_ie.data + legacy_ie.len);
-    return true;
-}
-
-bool convertLegacyIeBlobToAidl(const uint8_t* ie_blob, uint32_t ie_blob_len,
-                               std::vector<WifiInformationElement>* aidl_ies) {
-    if (!ie_blob || !aidl_ies) {
-        return false;
-    }
-    *aidl_ies = {};
-    const uint8_t* ies_begin = ie_blob;
-    const uint8_t* ies_end = ie_blob + ie_blob_len;
-    const uint8_t* next_ie = ies_begin;
-    using wifi_ie = legacy_hal::wifi_information_element;
-    constexpr size_t kIeHeaderLen = sizeof(wifi_ie);
-    // Each IE should at least have the header (i.e |id| & |len| fields).
-    while (next_ie + kIeHeaderLen <= ies_end) {
-        const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie));
-        uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len;
-        if (next_ie + curr_ie_len > ies_end) {
-            LOG(ERROR) << "Error parsing IE blob. Next IE: " << (void*)next_ie
-                       << ", Curr IE len: " << curr_ie_len << ", IEs End: " << (void*)ies_end;
-            break;
-        }
-        WifiInformationElement aidl_ie;
-        if (!convertLegacyIeToAidl(legacy_ie, &aidl_ie)) {
-            LOG(ERROR) << "Error converting IE. Id: " << legacy_ie.id << ", len: " << legacy_ie.len;
-            break;
-        }
-        aidl_ies->push_back(std::move(aidl_ie));
-        next_ie += curr_ie_len;
-    }
-    // Check if the blob has been fully consumed.
-    if (next_ie != ies_end) {
-        LOG(ERROR) << "Failed to fully parse IE blob. Next IE: " << (void*)next_ie
-                   << ", IEs End: " << (void*)ies_end;
-    }
-    return true;
-}
-
-bool convertLegacyGscanResultToAidl(const legacy_hal::wifi_scan_result& legacy_scan_result,
-                                    bool has_ie_data, StaScanResult* aidl_scan_result) {
-    if (!aidl_scan_result) {
-        return false;
-    }
-    *aidl_scan_result = {};
-    aidl_scan_result->timeStampInUs = legacy_scan_result.ts;
-    aidl_scan_result->ssid = std::vector<uint8_t>(
-            legacy_scan_result.ssid,
-            legacy_scan_result.ssid +
-                    strnlen(legacy_scan_result.ssid, sizeof(legacy_scan_result.ssid) - 1));
-    aidl_scan_result->bssid = std::array<uint8_t, 6>();
-    std::copy(legacy_scan_result.bssid, legacy_scan_result.bssid + 6,
-              std::begin(aidl_scan_result->bssid));
-    aidl_scan_result->frequency = legacy_scan_result.channel;
-    aidl_scan_result->rssi = legacy_scan_result.rssi;
-    aidl_scan_result->beaconPeriodInMs = legacy_scan_result.beacon_period;
-    aidl_scan_result->capability = legacy_scan_result.capability;
-    if (has_ie_data) {
-        std::vector<WifiInformationElement> ies;
-        if (!convertLegacyIeBlobToAidl(reinterpret_cast<const uint8_t*>(legacy_scan_result.ie_data),
-                                       legacy_scan_result.ie_length, &ies)) {
-            return false;
-        }
-        aidl_scan_result->informationElements = std::move(ies);
-    }
-    return true;
-}
-
-bool convertLegacyCachedGscanResultsToAidl(
-        const legacy_hal::wifi_cached_scan_results& legacy_cached_scan_result,
-        StaScanData* aidl_scan_data) {
-    if (!aidl_scan_data) {
-        return false;
-    }
-    *aidl_scan_data = {};
-    int32_t flags = 0;
-    for (const auto flag : {legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED}) {
-        if (legacy_cached_scan_result.flags & flag) {
-            flags |= static_cast<std::underlying_type<StaScanDataFlagMask>::type>(
-                    convertLegacyGscanDataFlagToAidl(flag));
-        }
-    }
-    aidl_scan_data->flags = static_cast<StaScanDataFlagMask>(flags);
-    aidl_scan_data->bucketsScanned = legacy_cached_scan_result.buckets_scanned;
-
-    CHECK(legacy_cached_scan_result.num_results >= 0 &&
-          legacy_cached_scan_result.num_results <= MAX_AP_CACHE_PER_SCAN);
-    std::vector<StaScanResult> aidl_scan_results;
-    for (int32_t result_idx = 0; result_idx < legacy_cached_scan_result.num_results; result_idx++) {
-        StaScanResult aidl_scan_result;
-        if (!convertLegacyGscanResultToAidl(legacy_cached_scan_result.results[result_idx], false,
-                                            &aidl_scan_result)) {
-            return false;
-        }
-        aidl_scan_results.push_back(aidl_scan_result);
-    }
-    aidl_scan_data->results = std::move(aidl_scan_results);
-    return true;
-}
-
-bool convertLegacyVectorOfCachedGscanResultsToAidl(
-        const std::vector<legacy_hal::wifi_cached_scan_results>& legacy_cached_scan_results,
-        std::vector<StaScanData>* aidl_scan_datas) {
-    if (!aidl_scan_datas) {
-        return false;
-    }
-    *aidl_scan_datas = {};
-    for (const auto& legacy_cached_scan_result : legacy_cached_scan_results) {
-        StaScanData aidl_scan_data;
-        if (!convertLegacyCachedGscanResultsToAidl(legacy_cached_scan_result, &aidl_scan_data)) {
-            return false;
-        }
-        aidl_scan_datas->push_back(aidl_scan_data);
-    }
-    return true;
-}
-
-WifiDebugTxPacketFate convertLegacyDebugTxPacketFateToAidl(legacy_hal::wifi_tx_packet_fate fate) {
-    switch (fate) {
-        case legacy_hal::TX_PKT_FATE_ACKED:
-            return WifiDebugTxPacketFate::ACKED;
-        case legacy_hal::TX_PKT_FATE_SENT:
-            return WifiDebugTxPacketFate::SENT;
-        case legacy_hal::TX_PKT_FATE_FW_QUEUED:
-            return WifiDebugTxPacketFate::FW_QUEUED;
-        case legacy_hal::TX_PKT_FATE_FW_DROP_INVALID:
-            return WifiDebugTxPacketFate::FW_DROP_INVALID;
-        case legacy_hal::TX_PKT_FATE_FW_DROP_NOBUFS:
-            return WifiDebugTxPacketFate::FW_DROP_NOBUFS;
-        case legacy_hal::TX_PKT_FATE_FW_DROP_OTHER:
-            return WifiDebugTxPacketFate::FW_DROP_OTHER;
-        case legacy_hal::TX_PKT_FATE_DRV_QUEUED:
-            return WifiDebugTxPacketFate::DRV_QUEUED;
-        case legacy_hal::TX_PKT_FATE_DRV_DROP_INVALID:
-            return WifiDebugTxPacketFate::DRV_DROP_INVALID;
-        case legacy_hal::TX_PKT_FATE_DRV_DROP_NOBUFS:
-            return WifiDebugTxPacketFate::DRV_DROP_NOBUFS;
-        case legacy_hal::TX_PKT_FATE_DRV_DROP_OTHER:
-            return WifiDebugTxPacketFate::DRV_DROP_OTHER;
-    };
-    CHECK(false) << "Unknown legacy fate type: " << fate;
-}
-
-WifiDebugRxPacketFate convertLegacyDebugRxPacketFateToAidl(legacy_hal::wifi_rx_packet_fate fate) {
-    switch (fate) {
-        case legacy_hal::RX_PKT_FATE_SUCCESS:
-            return WifiDebugRxPacketFate::SUCCESS;
-        case legacy_hal::RX_PKT_FATE_FW_QUEUED:
-            return WifiDebugRxPacketFate::FW_QUEUED;
-        case legacy_hal::RX_PKT_FATE_FW_DROP_FILTER:
-            return WifiDebugRxPacketFate::FW_DROP_FILTER;
-        case legacy_hal::RX_PKT_FATE_FW_DROP_INVALID:
-            return WifiDebugRxPacketFate::FW_DROP_INVALID;
-        case legacy_hal::RX_PKT_FATE_FW_DROP_NOBUFS:
-            return WifiDebugRxPacketFate::FW_DROP_NOBUFS;
-        case legacy_hal::RX_PKT_FATE_FW_DROP_OTHER:
-            return WifiDebugRxPacketFate::FW_DROP_OTHER;
-        case legacy_hal::RX_PKT_FATE_DRV_QUEUED:
-            return WifiDebugRxPacketFate::DRV_QUEUED;
-        case legacy_hal::RX_PKT_FATE_DRV_DROP_FILTER:
-            return WifiDebugRxPacketFate::DRV_DROP_FILTER;
-        case legacy_hal::RX_PKT_FATE_DRV_DROP_INVALID:
-            return WifiDebugRxPacketFate::DRV_DROP_INVALID;
-        case legacy_hal::RX_PKT_FATE_DRV_DROP_NOBUFS:
-            return WifiDebugRxPacketFate::DRV_DROP_NOBUFS;
-        case legacy_hal::RX_PKT_FATE_DRV_DROP_OTHER:
-            return WifiDebugRxPacketFate::DRV_DROP_OTHER;
-    };
-    CHECK(false) << "Unknown legacy fate type: " << fate;
-}
-
-WifiDebugPacketFateFrameType convertLegacyDebugPacketFateFrameTypeToAidl(
-        legacy_hal::frame_type type) {
-    switch (type) {
-        case legacy_hal::FRAME_TYPE_UNKNOWN:
-            return WifiDebugPacketFateFrameType::UNKNOWN;
-        case legacy_hal::FRAME_TYPE_ETHERNET_II:
-            return WifiDebugPacketFateFrameType::ETHERNET_II;
-        case legacy_hal::FRAME_TYPE_80211_MGMT:
-            return WifiDebugPacketFateFrameType::MGMT_80211;
-    };
-    CHECK(false) << "Unknown legacy frame type: " << type;
-}
-
-bool convertLegacyDebugPacketFateFrameToAidl(const legacy_hal::frame_info& legacy_frame,
-                                             WifiDebugPacketFateFrameInfo* aidl_frame) {
-    if (!aidl_frame) {
-        return false;
-    }
-    *aidl_frame = {};
-    aidl_frame->frameType = convertLegacyDebugPacketFateFrameTypeToAidl(legacy_frame.payload_type);
-    aidl_frame->frameLen = legacy_frame.frame_len;
-    aidl_frame->driverTimestampUsec = legacy_frame.driver_timestamp_usec;
-    aidl_frame->firmwareTimestampUsec = legacy_frame.firmware_timestamp_usec;
-    const uint8_t* frame_begin =
-            reinterpret_cast<const uint8_t*>(legacy_frame.frame_content.ethernet_ii_bytes);
-    aidl_frame->frameContent =
-            std::vector<uint8_t>(frame_begin, frame_begin + legacy_frame.frame_len);
-    return true;
-}
-
-bool convertLegacyDebugTxPacketFateToAidl(const legacy_hal::wifi_tx_report& legacy_fate,
-                                          WifiDebugTxPacketFateReport* aidl_fate) {
-    if (!aidl_fate) {
-        return false;
-    }
-    *aidl_fate = {};
-    aidl_fate->fate = convertLegacyDebugTxPacketFateToAidl(legacy_fate.fate);
-    return convertLegacyDebugPacketFateFrameToAidl(legacy_fate.frame_inf, &aidl_fate->frameInfo);
-}
-
-bool convertLegacyVectorOfDebugTxPacketFateToAidl(
-        const std::vector<legacy_hal::wifi_tx_report>& legacy_fates,
-        std::vector<WifiDebugTxPacketFateReport>* aidl_fates) {
-    if (!aidl_fates) {
-        return false;
-    }
-    *aidl_fates = {};
-    for (const auto& legacy_fate : legacy_fates) {
-        WifiDebugTxPacketFateReport aidl_fate;
-        if (!convertLegacyDebugTxPacketFateToAidl(legacy_fate, &aidl_fate)) {
-            return false;
-        }
-        aidl_fates->push_back(aidl_fate);
-    }
-    return true;
-}
-
-bool convertLegacyDebugRxPacketFateToAidl(const legacy_hal::wifi_rx_report& legacy_fate,
-                                          WifiDebugRxPacketFateReport* aidl_fate) {
-    if (!aidl_fate) {
-        return false;
-    }
-    *aidl_fate = {};
-    aidl_fate->fate = convertLegacyDebugRxPacketFateToAidl(legacy_fate.fate);
-    return convertLegacyDebugPacketFateFrameToAidl(legacy_fate.frame_inf, &aidl_fate->frameInfo);
-}
-
-bool convertLegacyVectorOfDebugRxPacketFateToAidl(
-        const std::vector<legacy_hal::wifi_rx_report>& legacy_fates,
-        std::vector<WifiDebugRxPacketFateReport>* aidl_fates) {
-    if (!aidl_fates) {
-        return false;
-    }
-    *aidl_fates = {};
-    for (const auto& legacy_fate : legacy_fates) {
-        WifiDebugRxPacketFateReport aidl_fate;
-        if (!convertLegacyDebugRxPacketFateToAidl(legacy_fate, &aidl_fate)) {
-            return false;
-        }
-        aidl_fates->push_back(aidl_fate);
-    }
-    return true;
-}
-
-bool convertLegacyLinkLayerRadioStatsToAidl(
-        const legacy_hal::LinkLayerRadioStats& legacy_radio_stat,
-        StaLinkLayerRadioStats* aidl_radio_stat) {
-    if (!aidl_radio_stat) {
-        return false;
-    }
-    *aidl_radio_stat = {};
-
-    aidl_radio_stat->radioId = legacy_radio_stat.stats.radio;
-    aidl_radio_stat->onTimeInMs = legacy_radio_stat.stats.on_time;
-    aidl_radio_stat->txTimeInMs = legacy_radio_stat.stats.tx_time;
-    aidl_radio_stat->rxTimeInMs = legacy_radio_stat.stats.rx_time;
-    aidl_radio_stat->onTimeInMsForScan = legacy_radio_stat.stats.on_time_scan;
-    aidl_radio_stat->txTimeInMsPerLevel = uintToIntVec(legacy_radio_stat.tx_time_per_levels);
-    aidl_radio_stat->onTimeInMsForNanScan = legacy_radio_stat.stats.on_time_nbd;
-    aidl_radio_stat->onTimeInMsForBgScan = legacy_radio_stat.stats.on_time_gscan;
-    aidl_radio_stat->onTimeInMsForRoamScan = legacy_radio_stat.stats.on_time_roam_scan;
-    aidl_radio_stat->onTimeInMsForPnoScan = legacy_radio_stat.stats.on_time_pno_scan;
-    aidl_radio_stat->onTimeInMsForHs20Scan = legacy_radio_stat.stats.on_time_hs20;
-
-    std::vector<WifiChannelStats> aidl_channel_stats;
-
-    for (const auto& channel_stat : legacy_radio_stat.channel_stats) {
-        WifiChannelStats aidl_channel_stat;
-        aidl_channel_stat.onTimeInMs = channel_stat.on_time;
-        aidl_channel_stat.ccaBusyTimeInMs = channel_stat.cca_busy_time;
-        aidl_channel_stat.channel.width = WifiChannelWidthInMhz::WIDTH_20;
-        aidl_channel_stat.channel.centerFreq = channel_stat.channel.center_freq;
-        aidl_channel_stat.channel.centerFreq0 = channel_stat.channel.center_freq0;
-        aidl_channel_stat.channel.centerFreq1 = channel_stat.channel.center_freq1;
-        aidl_channel_stats.push_back(aidl_channel_stat);
-    }
-
-    aidl_radio_stat->channelStats = aidl_channel_stats;
-
-    return true;
-}
-
-bool convertLegacyLinkLayerStatsToAidl(const legacy_hal::LinkLayerStats& legacy_stats,
-                                       StaLinkLayerStats* aidl_stats) {
-    if (!aidl_stats) {
-        return false;
-    }
-    *aidl_stats = {};
-    // iface legacy_stats conversion.
-    aidl_stats->iface.beaconRx = legacy_stats.iface.beacon_rx;
-    aidl_stats->iface.avgRssiMgmt = legacy_stats.iface.rssi_mgmt;
-    aidl_stats->iface.wmeBePktStats.rxMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu;
-    aidl_stats->iface.wmeBePktStats.txMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu;
-    aidl_stats->iface.wmeBePktStats.lostMpdu =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost;
-    aidl_stats->iface.wmeBePktStats.retries = legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries;
-    aidl_stats->iface.wmeBeContentionTimeStats.contentionTimeMinInUsec =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_min;
-    aidl_stats->iface.wmeBeContentionTimeStats.contentionTimeMaxInUsec =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_max;
-    aidl_stats->iface.wmeBeContentionTimeStats.contentionTimeAvgInUsec =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_avg;
-    aidl_stats->iface.wmeBeContentionTimeStats.contentionNumSamples =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples;
-    aidl_stats->iface.wmeBkPktStats.rxMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu;
-    aidl_stats->iface.wmeBkPktStats.txMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu;
-    aidl_stats->iface.wmeBkPktStats.lostMpdu =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost;
-    aidl_stats->iface.wmeBkPktStats.retries = legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries;
-    aidl_stats->iface.wmeBkContentionTimeStats.contentionTimeMinInUsec =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_min;
-    aidl_stats->iface.wmeBkContentionTimeStats.contentionTimeMaxInUsec =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_max;
-    aidl_stats->iface.wmeBkContentionTimeStats.contentionTimeAvgInUsec =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_avg;
-    aidl_stats->iface.wmeBkContentionTimeStats.contentionNumSamples =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples;
-    aidl_stats->iface.wmeViPktStats.rxMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu;
-    aidl_stats->iface.wmeViPktStats.txMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu;
-    aidl_stats->iface.wmeViPktStats.lostMpdu =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost;
-    aidl_stats->iface.wmeViPktStats.retries = legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries;
-    aidl_stats->iface.wmeViContentionTimeStats.contentionTimeMinInUsec =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_min;
-    aidl_stats->iface.wmeViContentionTimeStats.contentionTimeMaxInUsec =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_max;
-    aidl_stats->iface.wmeViContentionTimeStats.contentionTimeAvgInUsec =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_avg;
-    aidl_stats->iface.wmeViContentionTimeStats.contentionNumSamples =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples;
-    aidl_stats->iface.wmeVoPktStats.rxMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu;
-    aidl_stats->iface.wmeVoPktStats.txMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu;
-    aidl_stats->iface.wmeVoPktStats.lostMpdu =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost;
-    aidl_stats->iface.wmeVoPktStats.retries = legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries;
-    aidl_stats->iface.wmeVoContentionTimeStats.contentionTimeMinInUsec =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_min;
-    aidl_stats->iface.wmeVoContentionTimeStats.contentionTimeMaxInUsec =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_max;
-    aidl_stats->iface.wmeVoContentionTimeStats.contentionTimeAvgInUsec =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_avg;
-    aidl_stats->iface.wmeVoContentionTimeStats.contentionNumSamples =
-            legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples;
-    aidl_stats->iface.timeSliceDutyCycleInPercent =
-            legacy_stats.iface.info.time_slicing_duty_cycle_percent;
-    // peer info legacy_stats conversion.
-    std::vector<StaPeerInfo> aidl_peers_info_stats;
-    for (const auto& legacy_peer_info_stats : legacy_stats.peers) {
-        StaPeerInfo aidl_peer_info_stats;
-        if (!convertLegacyPeerInfoStatsToAidl(legacy_peer_info_stats, &aidl_peer_info_stats)) {
-            return false;
-        }
-        aidl_peers_info_stats.push_back(aidl_peer_info_stats);
-    }
-    aidl_stats->iface.peers = aidl_peers_info_stats;
-    // radio legacy_stats conversion.
-    std::vector<StaLinkLayerRadioStats> aidl_radios_stats;
-    for (const auto& legacy_radio_stats : legacy_stats.radios) {
-        StaLinkLayerRadioStats aidl_radio_stats;
-        if (!convertLegacyLinkLayerRadioStatsToAidl(legacy_radio_stats, &aidl_radio_stats)) {
-            return false;
-        }
-        aidl_radios_stats.push_back(aidl_radio_stats);
-    }
-    aidl_stats->radios = aidl_radios_stats;
-    aidl_stats->timeStampInMs = ::android::uptimeMillis();
-    return true;
-}
-
-bool convertLegacyPeerInfoStatsToAidl(const legacy_hal::WifiPeerInfo& legacy_peer_info_stats,
-                                      StaPeerInfo* aidl_peer_info_stats) {
-    if (!aidl_peer_info_stats) {
-        return false;
-    }
-    *aidl_peer_info_stats = {};
-    aidl_peer_info_stats->staCount = legacy_peer_info_stats.peer_info.bssload.sta_count;
-    aidl_peer_info_stats->chanUtil = legacy_peer_info_stats.peer_info.bssload.chan_util;
-
-    std::vector<StaRateStat> aidlRateStats;
-    for (const auto& legacy_rate_stats : legacy_peer_info_stats.rate_stats) {
-        StaRateStat rateStat;
-        if (!convertLegacyWifiRateInfoToAidl(legacy_rate_stats.rate, &rateStat.rateInfo)) {
-            return false;
-        }
-        rateStat.txMpdu = legacy_rate_stats.tx_mpdu;
-        rateStat.rxMpdu = legacy_rate_stats.rx_mpdu;
-        rateStat.mpduLost = legacy_rate_stats.mpdu_lost;
-        rateStat.retries = legacy_rate_stats.retries;
-        aidlRateStats.push_back(rateStat);
-    }
-    aidl_peer_info_stats->rateStats = aidlRateStats;
-    return true;
-}
-
-bool convertLegacyRoamingCapabilitiesToAidl(
-        const legacy_hal::wifi_roaming_capabilities& legacy_caps,
-        StaRoamingCapabilities* aidl_caps) {
-    if (!aidl_caps) {
-        return false;
-    }
-    *aidl_caps = {};
-    aidl_caps->maxBlocklistSize = legacy_caps.max_blacklist_size;
-    aidl_caps->maxAllowlistSize = legacy_caps.max_whitelist_size;
-    return true;
-}
-
-bool convertAidlRoamingConfigToLegacy(const StaRoamingConfig& aidl_config,
-                                      legacy_hal::wifi_roaming_config* legacy_config) {
-    if (!legacy_config) {
-        return false;
-    }
-    *legacy_config = {};
-    if (aidl_config.bssidBlocklist.size() > MAX_BLACKLIST_BSSID ||
-        aidl_config.ssidAllowlist.size() > MAX_WHITELIST_SSID) {
-        return false;
-    }
-    legacy_config->num_blacklist_bssid = aidl_config.bssidBlocklist.size();
-    uint32_t i = 0;
-    for (const auto& bssid : aidl_config.bssidBlocklist) {
-        CHECK(bssid.data.size() == sizeof(legacy_hal::mac_addr));
-        memcpy(legacy_config->blacklist_bssid[i++], bssid.data.data(), bssid.data.size());
-    }
-    legacy_config->num_whitelist_ssid = aidl_config.ssidAllowlist.size();
-    i = 0;
-    for (const auto& ssid : aidl_config.ssidAllowlist) {
-        CHECK(ssid.data.size() <= sizeof(legacy_hal::ssid_t::ssid_str));
-        legacy_config->whitelist_ssid[i].length = ssid.data.size();
-        memcpy(legacy_config->whitelist_ssid[i].ssid_str, ssid.data.data(), ssid.data.size());
-        i++;
-    }
-    return true;
-}
-
-legacy_hal::fw_roaming_state_t convertAidlRoamingStateToLegacy(StaRoamingState state) {
-    switch (state) {
-        case StaRoamingState::ENABLED:
-            return legacy_hal::ROAMING_ENABLE;
-        case StaRoamingState::DISABLED:
-            return legacy_hal::ROAMING_DISABLE;
-    };
-    CHECK(false);
-}
-
-legacy_hal::NanMatchAlg convertAidlNanMatchAlgToLegacy(NanMatchAlg type) {
-    switch (type) {
-        case NanMatchAlg::MATCH_ONCE:
-            return legacy_hal::NAN_MATCH_ALG_MATCH_ONCE;
-        case NanMatchAlg::MATCH_CONTINUOUS:
-            return legacy_hal::NAN_MATCH_ALG_MATCH_CONTINUOUS;
-        case NanMatchAlg::MATCH_NEVER:
-            return legacy_hal::NAN_MATCH_ALG_MATCH_NEVER;
-    }
-    CHECK(false);
-}
-
-legacy_hal::NanPublishType convertAidlNanPublishTypeToLegacy(NanPublishType type) {
-    switch (type) {
-        case NanPublishType::UNSOLICITED:
-            return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED;
-        case NanPublishType::SOLICITED:
-            return legacy_hal::NAN_PUBLISH_TYPE_SOLICITED;
-        case NanPublishType::UNSOLICITED_SOLICITED:
-            return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
-    }
-    CHECK(false);
-}
-
-legacy_hal::NanTxType convertAidlNanTxTypeToLegacy(NanTxType type) {
-    switch (type) {
-        case NanTxType::BROADCAST:
-            return legacy_hal::NAN_TX_TYPE_BROADCAST;
-        case NanTxType::UNICAST:
-            return legacy_hal::NAN_TX_TYPE_UNICAST;
-    }
-    CHECK(false);
-}
-
-legacy_hal::NanSubscribeType convertAidlNanSubscribeTypeToLegacy(NanSubscribeType type) {
-    switch (type) {
-        case NanSubscribeType::PASSIVE:
-            return legacy_hal::NAN_SUBSCRIBE_TYPE_PASSIVE;
-        case NanSubscribeType::ACTIVE:
-            return legacy_hal::NAN_SUBSCRIBE_TYPE_ACTIVE;
-    }
-    CHECK(false);
-}
-
-legacy_hal::NanSRFType convertAidlNanSrfTypeToLegacy(NanSrfType type) {
-    switch (type) {
-        case NanSrfType::BLOOM_FILTER:
-            return legacy_hal::NAN_SRF_ATTR_BLOOM_FILTER;
-        case NanSrfType::PARTIAL_MAC_ADDR:
-            return legacy_hal::NAN_SRF_ATTR_PARTIAL_MAC_ADDR;
-    }
-    CHECK(false);
-}
-
-legacy_hal::NanDataPathChannelCfg convertAidlNanDataPathChannelCfgToLegacy(
-        NanDataPathChannelCfg type) {
-    switch (type) {
-        case NanDataPathChannelCfg::CHANNEL_NOT_REQUESTED:
-            return legacy_hal::NAN_DP_CHANNEL_NOT_REQUESTED;
-        case NanDataPathChannelCfg::REQUEST_CHANNEL_SETUP:
-            return legacy_hal::NAN_DP_REQUEST_CHANNEL_SETUP;
-        case NanDataPathChannelCfg::FORCE_CHANNEL_SETUP:
-            return legacy_hal::NAN_DP_FORCE_CHANNEL_SETUP;
-    }
-    CHECK(false);
-}
-
-NanStatusCode convertLegacyNanStatusTypeToAidl(legacy_hal::NanStatusType type) {
-    switch (type) {
-        case legacy_hal::NAN_STATUS_SUCCESS:
-            return NanStatusCode::SUCCESS;
-        case legacy_hal::NAN_STATUS_INTERNAL_FAILURE:
-            return NanStatusCode::INTERNAL_FAILURE;
-        case legacy_hal::NAN_STATUS_PROTOCOL_FAILURE:
-            return NanStatusCode::PROTOCOL_FAILURE;
-        case legacy_hal::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID:
-            return NanStatusCode::INVALID_SESSION_ID;
-        case legacy_hal::NAN_STATUS_NO_RESOURCE_AVAILABLE:
-            return NanStatusCode::NO_RESOURCES_AVAILABLE;
-        case legacy_hal::NAN_STATUS_INVALID_PARAM:
-            return NanStatusCode::INVALID_ARGS;
-        case legacy_hal::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID:
-            return NanStatusCode::INVALID_PEER_ID;
-        case legacy_hal::NAN_STATUS_INVALID_NDP_ID:
-            return NanStatusCode::INVALID_NDP_ID;
-        case legacy_hal::NAN_STATUS_NAN_NOT_ALLOWED:
-            return NanStatusCode::NAN_NOT_ALLOWED;
-        case legacy_hal::NAN_STATUS_NO_OTA_ACK:
-            return NanStatusCode::NO_OTA_ACK;
-        case legacy_hal::NAN_STATUS_ALREADY_ENABLED:
-            return NanStatusCode::ALREADY_ENABLED;
-        case legacy_hal::NAN_STATUS_FOLLOWUP_QUEUE_FULL:
-            return NanStatusCode::FOLLOWUP_TX_QUEUE_FULL;
-        case legacy_hal::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED:
-            return NanStatusCode::UNSUPPORTED_CONCURRENCY_NAN_DISABLED;
-    }
-    CHECK(false);
-}
-
-void convertToNanStatus(legacy_hal::NanStatusType type, const char* str, size_t max_len,
-                        NanStatus* nanStatus) {
-    nanStatus->status = convertLegacyNanStatusTypeToAidl(type);
-    nanStatus->description = safeConvertChar(str, max_len);
-}
-
-bool convertAidlNanEnableRequestToLegacy(const NanEnableRequest& aidl_request1,
-                                         const NanConfigRequestSupplemental& aidl_request2,
-                                         legacy_hal::NanEnableRequest* legacy_request) {
-    if (!legacy_request) {
-        LOG(ERROR) << "convertAidlNanEnableRequestToLegacy: null legacy_request";
-        return false;
-    }
-    *legacy_request = {};
-
-    legacy_request->config_2dot4g_support = 1;
-    legacy_request->support_2dot4g_val =
-            aidl_request1.operateInBand[(size_t)NanBandIndex::NAN_BAND_24GHZ];
-    legacy_request->config_support_5g = 1;
-    legacy_request->support_5g_val =
-            aidl_request1.operateInBand[(size_t)NanBandIndex::NAN_BAND_5GHZ];
-    legacy_request->config_hop_count_limit = 1;
-    legacy_request->hop_count_limit_val = aidl_request1.hopCountMax;
-    legacy_request->master_pref = aidl_request1.configParams.masterPref;
-    legacy_request->discovery_indication_cfg = 0;
-    legacy_request->discovery_indication_cfg |=
-            aidl_request1.configParams.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
-    legacy_request->discovery_indication_cfg |=
-            aidl_request1.configParams.disableStartedClusterIndication ? 0x2 : 0x0;
-    legacy_request->discovery_indication_cfg |=
-            aidl_request1.configParams.disableJoinedClusterIndication ? 0x4 : 0x0;
-    legacy_request->config_sid_beacon = 1;
-    if (aidl_request1.configParams.numberOfPublishServiceIdsInBeacon < 0) {
-        LOG(ERROR) << "convertAidlNanEnableRequestToLegacy: "
-                      "numberOfPublishServiceIdsInBeacon < 0";
-        return false;
-    }
-    legacy_request->sid_beacon_val =
-            (aidl_request1.configParams.includePublishServiceIdsInBeacon ? 0x1 : 0x0) |
-            (aidl_request1.configParams.numberOfPublishServiceIdsInBeacon << 1);
-    legacy_request->config_subscribe_sid_beacon = 1;
-    if (aidl_request1.configParams.numberOfSubscribeServiceIdsInBeacon < 0) {
-        LOG(ERROR) << "convertAidlNanEnableRequestToLegacy: "
-                      "numberOfSubscribeServiceIdsInBeacon < 0";
-        return false;
-    }
-    legacy_request->subscribe_sid_beacon_val =
-            (aidl_request1.configParams.includeSubscribeServiceIdsInBeacon ? 0x1 : 0x0) |
-            (aidl_request1.configParams.numberOfSubscribeServiceIdsInBeacon << 1);
-    legacy_request->config_rssi_window_size = 1;
-    legacy_request->rssi_window_size_val = aidl_request1.configParams.rssiWindowSize;
-    legacy_request->config_disc_mac_addr_randomization = 1;
-    legacy_request->disc_mac_addr_rand_interval_sec =
-            aidl_request1.configParams.macAddressRandomizationIntervalSec;
-    legacy_request->config_2dot4g_rssi_close = 1;
-    if (aidl_request1.configParams.bandSpecificConfig.size() != 3) {
-        LOG(ERROR) << "convertAidlNanEnableRequestToLegacy: "
-                      "bandSpecificConfig.size() != 3";
-        return false;
-    }
-    legacy_request->rssi_close_2dot4g_val =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
-                    .rssiClose;
-    legacy_request->config_2dot4g_rssi_middle = 1;
-    legacy_request->rssi_middle_2dot4g_val =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
-                    .rssiMiddle;
-    legacy_request->config_2dot4g_rssi_proximity = 1;
-    legacy_request->rssi_proximity_2dot4g_val =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
-                    .rssiCloseProximity;
-    legacy_request->config_scan_params = 1;
-    legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
-                    .dwellTimeMs;
-    legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
-                    .scanPeriodSec;
-    legacy_request->config_dw.config_2dot4g_dw_band =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
-                    .validDiscoveryWindowIntervalVal;
-    legacy_request->config_dw.dw_2dot4g_interval_val =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
-                    .discoveryWindowIntervalVal;
-    legacy_request->config_5g_rssi_close = 1;
-    legacy_request->rssi_close_5g_val =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
-                    .rssiClose;
-    legacy_request->config_5g_rssi_middle = 1;
-    legacy_request->rssi_middle_5g_val =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
-                    .rssiMiddle;
-    legacy_request->config_5g_rssi_close_proximity = 1;
-    legacy_request->rssi_close_proximity_5g_val =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
-                    .rssiCloseProximity;
-    legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
-                    .dwellTimeMs;
-    legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
-                    .scanPeriodSec;
-    legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
-                    .dwellTimeMs;
-    legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
-                    .scanPeriodSec;
-    legacy_request->config_dw.config_5g_dw_band =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
-                    .validDiscoveryWindowIntervalVal;
-    legacy_request->config_dw.dw_5g_interval_val =
-            aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
-                    .discoveryWindowIntervalVal;
-    if (aidl_request1.debugConfigs.validClusterIdVals) {
-        legacy_request->cluster_low = aidl_request1.debugConfigs.clusterIdBottomRangeVal;
-        legacy_request->cluster_high = aidl_request1.debugConfigs.clusterIdTopRangeVal;
-    } else {  // need 'else' since not configurable in legacy HAL
-        legacy_request->cluster_low = 0x0000;
-        legacy_request->cluster_high = 0xFFFF;
-    }
-    legacy_request->config_intf_addr = aidl_request1.debugConfigs.validIntfAddrVal;
-    memcpy(legacy_request->intf_addr_val, aidl_request1.debugConfigs.intfAddrVal.data(), 6);
-    legacy_request->config_oui = aidl_request1.debugConfigs.validOuiVal;
-    legacy_request->oui_val = aidl_request1.debugConfigs.ouiVal;
-    legacy_request->config_random_factor_force =
-            aidl_request1.debugConfigs.validRandomFactorForceVal;
-    legacy_request->random_factor_force_val = aidl_request1.debugConfigs.randomFactorForceVal;
-    legacy_request->config_hop_count_force = aidl_request1.debugConfigs.validHopCountForceVal;
-    legacy_request->hop_count_force_val = aidl_request1.debugConfigs.hopCountForceVal;
-    legacy_request->config_24g_channel = aidl_request1.debugConfigs.validDiscoveryChannelVal;
-    legacy_request->channel_24g_val =
-            aidl_request1.debugConfigs.discoveryChannelMhzVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
-    legacy_request->config_5g_channel = aidl_request1.debugConfigs.validDiscoveryChannelVal;
-    legacy_request->channel_5g_val =
-            aidl_request1.debugConfigs.discoveryChannelMhzVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
-    legacy_request->config_2dot4g_beacons = aidl_request1.debugConfigs.validUseBeaconsInBandVal;
-    legacy_request->beacon_2dot4g_val =
-            aidl_request1.debugConfigs.useBeaconsInBandVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
-    legacy_request->config_5g_beacons = aidl_request1.debugConfigs.validUseBeaconsInBandVal;
-    legacy_request->beacon_5g_val =
-            aidl_request1.debugConfigs.useBeaconsInBandVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
-    legacy_request->config_2dot4g_sdf = aidl_request1.debugConfigs.validUseSdfInBandVal;
-    legacy_request->sdf_2dot4g_val =
-            aidl_request1.debugConfigs.useSdfInBandVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
-    legacy_request->config_5g_sdf = aidl_request1.debugConfigs.validUseSdfInBandVal;
-    legacy_request->sdf_5g_val =
-            aidl_request1.debugConfigs.useSdfInBandVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
-
-    legacy_request->config_discovery_beacon_int = 1;
-    legacy_request->discovery_beacon_interval = aidl_request2.discoveryBeaconIntervalMs;
-    legacy_request->config_nss = 1;
-    legacy_request->nss = aidl_request2.numberOfSpatialStreamsInDiscovery;
-    legacy_request->config_dw_early_termination = 1;
-    legacy_request->enable_dw_termination = aidl_request2.enableDiscoveryWindowEarlyTermination;
-    legacy_request->config_enable_ranging = 1;
-    legacy_request->enable_ranging = aidl_request2.enableRanging;
-
-    legacy_request->config_enable_instant_mode = 1;
-    legacy_request->enable_instant_mode = aidl_request2.enableInstantCommunicationMode;
-    legacy_request->config_instant_mode_channel = 1;
-    legacy_request->instant_mode_channel = aidl_request2.instantModeChannel;
-
-    return true;
-}
-
-bool convertAidlNanConfigRequestToLegacy(const NanConfigRequest& aidl_request1,
-                                         const NanConfigRequestSupplemental& aidl_request2,
-                                         legacy_hal::NanConfigRequest* legacy_request) {
-    if (!legacy_request) {
-        LOG(ERROR) << "convertAidlNanConfigRequestToLegacy: null legacy_request";
-        return false;
-    }
-    *legacy_request = {};
-
-    legacy_request->master_pref = aidl_request1.masterPref;
-    legacy_request->discovery_indication_cfg = 0;
-    legacy_request->discovery_indication_cfg |=
-            aidl_request1.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
-    legacy_request->discovery_indication_cfg |=
-            aidl_request1.disableStartedClusterIndication ? 0x2 : 0x0;
-    legacy_request->discovery_indication_cfg |=
-            aidl_request1.disableJoinedClusterIndication ? 0x4 : 0x0;
-    legacy_request->config_sid_beacon = 1;
-    if (aidl_request1.numberOfPublishServiceIdsInBeacon < 0) {
-        LOG(ERROR) << "convertAidlNanConfigRequestToLegacy: "
-                      "numberOfPublishServiceIdsInBeacon < 0";
-        return false;
-    }
-    legacy_request->sid_beacon = (aidl_request1.includePublishServiceIdsInBeacon ? 0x1 : 0x0) |
-                                 (aidl_request1.numberOfPublishServiceIdsInBeacon << 1);
-    legacy_request->config_subscribe_sid_beacon = 1;
-    if (aidl_request1.numberOfSubscribeServiceIdsInBeacon < 0) {
-        LOG(ERROR) << "convertAidlNanConfigRequestToLegacy: "
-                      "numberOfSubscribeServiceIdsInBeacon < 0";
-        return false;
-    }
-    legacy_request->subscribe_sid_beacon_val =
-            (aidl_request1.includeSubscribeServiceIdsInBeacon ? 0x1 : 0x0) |
-            (aidl_request1.numberOfSubscribeServiceIdsInBeacon << 1);
-    legacy_request->config_rssi_window_size = 1;
-    legacy_request->rssi_window_size_val = aidl_request1.rssiWindowSize;
-    legacy_request->config_disc_mac_addr_randomization = 1;
-    legacy_request->disc_mac_addr_rand_interval_sec =
-            aidl_request1.macAddressRandomizationIntervalSec;
-
-    legacy_request->config_scan_params = 1;
-    legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
-            aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ].dwellTimeMs;
-    legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
-            aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ].scanPeriodSec;
-    legacy_request->config_dw.config_2dot4g_dw_band =
-            aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
-                    .validDiscoveryWindowIntervalVal;
-    legacy_request->config_dw.dw_2dot4g_interval_val =
-            aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
-                    .discoveryWindowIntervalVal;
-
-    legacy_request->config_5g_rssi_close_proximity = 1;
-    legacy_request->rssi_close_proximity_5g_val =
-            aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
-                    .rssiCloseProximity;
-    legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
-            aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
-    legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
-            aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
-    legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
-            aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
-    legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
-            aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
-    legacy_request->config_dw.config_5g_dw_band =
-            aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
-                    .validDiscoveryWindowIntervalVal;
-    legacy_request->config_dw.dw_5g_interval_val =
-            aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
-                    .discoveryWindowIntervalVal;
-
-    legacy_request->config_discovery_beacon_int = 1;
-    legacy_request->discovery_beacon_interval = aidl_request2.discoveryBeaconIntervalMs;
-    legacy_request->config_nss = 1;
-    legacy_request->nss = aidl_request2.numberOfSpatialStreamsInDiscovery;
-    legacy_request->config_dw_early_termination = 1;
-    legacy_request->enable_dw_termination = aidl_request2.enableDiscoveryWindowEarlyTermination;
-    legacy_request->config_enable_ranging = 1;
-    legacy_request->enable_ranging = aidl_request2.enableRanging;
-
-    legacy_request->config_enable_instant_mode = 1;
-    legacy_request->enable_instant_mode = aidl_request2.enableInstantCommunicationMode;
-    legacy_request->config_instant_mode_channel = 1;
-    legacy_request->instant_mode_channel = aidl_request2.instantModeChannel;
-
-    return true;
-}
-
-bool convertAidlNanPublishRequestToLegacy(const NanPublishRequest& aidl_request,
-                                          legacy_hal::NanPublishRequest* legacy_request) {
-    if (!legacy_request) {
-        LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: null legacy_request";
-        return false;
-    }
-    *legacy_request = {};
-
-    legacy_request->publish_id = aidl_request.baseConfigs.sessionId;
-    legacy_request->ttl = aidl_request.baseConfigs.ttlSec;
-    legacy_request->period = aidl_request.baseConfigs.discoveryWindowPeriod;
-    legacy_request->publish_count = aidl_request.baseConfigs.discoveryCount;
-    legacy_request->service_name_len = aidl_request.baseConfigs.serviceName.size();
-    if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
-        LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: service_name_len "
-                      "too large";
-        return false;
-    }
-    memcpy(legacy_request->service_name, aidl_request.baseConfigs.serviceName.data(),
-           legacy_request->service_name_len);
-    legacy_request->publish_match_indicator =
-            convertAidlNanMatchAlgToLegacy(aidl_request.baseConfigs.discoveryMatchIndicator);
-    legacy_request->service_specific_info_len = aidl_request.baseConfigs.serviceSpecificInfo.size();
-    if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
-        LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: "
-                      "service_specific_info_len too large";
-        return false;
-    }
-    memcpy(legacy_request->service_specific_info,
-           aidl_request.baseConfigs.serviceSpecificInfo.data(),
-           legacy_request->service_specific_info_len);
-    legacy_request->sdea_service_specific_info_len =
-            aidl_request.baseConfigs.extendedServiceSpecificInfo.size();
-    if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
-        LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: "
-                      "sdea_service_specific_info_len too large";
-        return false;
-    }
-    memcpy(legacy_request->sdea_service_specific_info,
-           aidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
-           legacy_request->sdea_service_specific_info_len);
-    legacy_request->rx_match_filter_len = aidl_request.baseConfigs.rxMatchFilter.size();
-    if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
-        LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: "
-                      "rx_match_filter_len too large";
-        return false;
-    }
-    memcpy(legacy_request->rx_match_filter, aidl_request.baseConfigs.rxMatchFilter.data(),
-           legacy_request->rx_match_filter_len);
-    legacy_request->tx_match_filter_len = aidl_request.baseConfigs.txMatchFilter.size();
-    if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
-        LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: "
-                      "tx_match_filter_len too large";
-        return false;
-    }
-    memcpy(legacy_request->tx_match_filter, aidl_request.baseConfigs.txMatchFilter.data(),
-           legacy_request->tx_match_filter_len);
-    legacy_request->rssi_threshold_flag = aidl_request.baseConfigs.useRssiThreshold;
-    legacy_request->recv_indication_cfg = 0;
-    legacy_request->recv_indication_cfg |=
-            aidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1 : 0x0;
-    legacy_request->recv_indication_cfg |=
-            aidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
-    legacy_request->recv_indication_cfg |=
-            aidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
-    legacy_request->recv_indication_cfg |= 0x8;
-    legacy_request->cipher_type = (unsigned int)aidl_request.baseConfigs.securityConfig.cipherType;
-
-    legacy_request->scid_len = aidl_request.baseConfigs.securityConfig.scid.size();
-    if (legacy_request->scid_len > NAN_MAX_SCID_BUF_LEN) {
-        LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: scid_len too large";
-        return false;
-    }
-    memcpy(legacy_request->scid, aidl_request.baseConfigs.securityConfig.scid.data(),
-           legacy_request->scid_len);
-
-    if (aidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PMK) {
-        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
-        legacy_request->key_info.body.pmk_info.pmk_len =
-                aidl_request.baseConfigs.securityConfig.pmk.size();
-        if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
-            LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: invalid pmk_len";
-            return false;
-        }
-        memcpy(legacy_request->key_info.body.pmk_info.pmk,
-               aidl_request.baseConfigs.securityConfig.pmk.data(),
-               legacy_request->key_info.body.pmk_info.pmk_len);
-    }
-    if (aidl_request.baseConfigs.securityConfig.securityType ==
-        NanDataPathSecurityType::PASSPHRASE) {
-        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
-        legacy_request->key_info.body.passphrase_info.passphrase_len =
-                aidl_request.baseConfigs.securityConfig.passphrase.size();
-        if (legacy_request->key_info.body.passphrase_info.passphrase_len <
-            NAN_SECURITY_MIN_PASSPHRASE_LEN) {
-            LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: "
-                          "passphrase_len too small";
-            return false;
-        }
-        if (legacy_request->key_info.body.passphrase_info.passphrase_len >
-            NAN_SECURITY_MAX_PASSPHRASE_LEN) {
-            LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: "
-                          "passphrase_len too large";
-            return false;
-        }
-        memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
-               aidl_request.baseConfigs.securityConfig.passphrase.data(),
-               legacy_request->key_info.body.passphrase_info.passphrase_len);
-    }
-    legacy_request->sdea_params.security_cfg =
-            (aidl_request.baseConfigs.securityConfig.securityType != NanDataPathSecurityType::OPEN)
-                    ? legacy_hal::NAN_DP_CONFIG_SECURITY
-                    : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
-
-    legacy_request->sdea_params.ranging_state = aidl_request.baseConfigs.rangingRequired
-                                                        ? legacy_hal::NAN_RANGING_ENABLE
-                                                        : legacy_hal::NAN_RANGING_DISABLE;
-    legacy_request->ranging_cfg.ranging_interval_msec = aidl_request.baseConfigs.rangingIntervalMs;
-    legacy_request->ranging_cfg.config_ranging_indications =
-            static_cast<uint32_t>(aidl_request.baseConfigs.configRangingIndications);
-    legacy_request->ranging_cfg.distance_ingress_mm =
-            aidl_request.baseConfigs.distanceIngressCm * 10;
-    legacy_request->ranging_cfg.distance_egress_mm = aidl_request.baseConfigs.distanceEgressCm * 10;
-    legacy_request->ranging_auto_response = aidl_request.baseConfigs.rangingRequired
-                                                    ? legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE
-                                                    : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
-    legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT;
-    legacy_request->publish_type = convertAidlNanPublishTypeToLegacy(aidl_request.publishType);
-    legacy_request->tx_type = convertAidlNanTxTypeToLegacy(aidl_request.txType);
-    legacy_request->service_responder_policy = aidl_request.autoAcceptDataPathRequests
-                                                       ? legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL
-                                                       : legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE;
-
-    return true;
-}
-
-bool convertAidlNanSubscribeRequestToLegacy(const NanSubscribeRequest& aidl_request,
-                                            legacy_hal::NanSubscribeRequest* legacy_request) {
-    if (!legacy_request) {
-        LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: legacy_request is null";
-        return false;
-    }
-    *legacy_request = {};
-
-    legacy_request->subscribe_id = aidl_request.baseConfigs.sessionId;
-    legacy_request->ttl = aidl_request.baseConfigs.ttlSec;
-    legacy_request->period = aidl_request.baseConfigs.discoveryWindowPeriod;
-    legacy_request->subscribe_count = aidl_request.baseConfigs.discoveryCount;
-    legacy_request->service_name_len = aidl_request.baseConfigs.serviceName.size();
-    if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
-        LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
-                      "service_name_len too large";
-        return false;
-    }
-    memcpy(legacy_request->service_name, aidl_request.baseConfigs.serviceName.data(),
-           legacy_request->service_name_len);
-    legacy_request->subscribe_match_indicator =
-            convertAidlNanMatchAlgToLegacy(aidl_request.baseConfigs.discoveryMatchIndicator);
-    legacy_request->service_specific_info_len = aidl_request.baseConfigs.serviceSpecificInfo.size();
-    if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
-        LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
-                      "service_specific_info_len too large";
-        return false;
-    }
-    memcpy(legacy_request->service_specific_info,
-           aidl_request.baseConfigs.serviceSpecificInfo.data(),
-           legacy_request->service_specific_info_len);
-    legacy_request->sdea_service_specific_info_len =
-            aidl_request.baseConfigs.extendedServiceSpecificInfo.size();
-    if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
-        LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
-                      "sdea_service_specific_info_len too large";
-        return false;
-    }
-    memcpy(legacy_request->sdea_service_specific_info,
-           aidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
-           legacy_request->sdea_service_specific_info_len);
-    legacy_request->rx_match_filter_len = aidl_request.baseConfigs.rxMatchFilter.size();
-    if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
-        LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
-                      "rx_match_filter_len too large";
-        return false;
-    }
-    memcpy(legacy_request->rx_match_filter, aidl_request.baseConfigs.rxMatchFilter.data(),
-           legacy_request->rx_match_filter_len);
-    legacy_request->tx_match_filter_len = aidl_request.baseConfigs.txMatchFilter.size();
-    if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
-        LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
-                      "tx_match_filter_len too large";
-        return false;
-    }
-    memcpy(legacy_request->tx_match_filter, aidl_request.baseConfigs.txMatchFilter.data(),
-           legacy_request->tx_match_filter_len);
-    legacy_request->rssi_threshold_flag = aidl_request.baseConfigs.useRssiThreshold;
-    legacy_request->recv_indication_cfg = 0;
-    legacy_request->recv_indication_cfg |=
-            aidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1 : 0x0;
-    legacy_request->recv_indication_cfg |=
-            aidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
-    legacy_request->recv_indication_cfg |=
-            aidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
-    legacy_request->cipher_type = (unsigned int)aidl_request.baseConfigs.securityConfig.cipherType;
-    if (aidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PMK) {
-        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
-        legacy_request->key_info.body.pmk_info.pmk_len =
-                aidl_request.baseConfigs.securityConfig.pmk.size();
-        if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
-            LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: invalid pmk_len";
-            return false;
-        }
-        memcpy(legacy_request->key_info.body.pmk_info.pmk,
-               aidl_request.baseConfigs.securityConfig.pmk.data(),
-               legacy_request->key_info.body.pmk_info.pmk_len);
-    }
-    if (aidl_request.baseConfigs.securityConfig.securityType ==
-        NanDataPathSecurityType::PASSPHRASE) {
-        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
-        legacy_request->key_info.body.passphrase_info.passphrase_len =
-                aidl_request.baseConfigs.securityConfig.passphrase.size();
-        if (legacy_request->key_info.body.passphrase_info.passphrase_len <
-            NAN_SECURITY_MIN_PASSPHRASE_LEN) {
-            LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
-                          "passphrase_len too small";
-            return false;
-        }
-        if (legacy_request->key_info.body.passphrase_info.passphrase_len >
-            NAN_SECURITY_MAX_PASSPHRASE_LEN) {
-            LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
-                          "passphrase_len too large";
-            return false;
-        }
-        memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
-               aidl_request.baseConfigs.securityConfig.passphrase.data(),
-               legacy_request->key_info.body.passphrase_info.passphrase_len);
-    }
-    legacy_request->sdea_params.security_cfg =
-            (aidl_request.baseConfigs.securityConfig.securityType != NanDataPathSecurityType::OPEN)
-                    ? legacy_hal::NAN_DP_CONFIG_SECURITY
-                    : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
-    legacy_request->sdea_params.ranging_state = aidl_request.baseConfigs.rangingRequired
-                                                        ? legacy_hal::NAN_RANGING_ENABLE
-                                                        : legacy_hal::NAN_RANGING_DISABLE;
-    legacy_request->ranging_cfg.ranging_interval_msec = aidl_request.baseConfigs.rangingIntervalMs;
-    legacy_request->ranging_cfg.config_ranging_indications =
-            static_cast<uint32_t>(aidl_request.baseConfigs.configRangingIndications);
-    legacy_request->ranging_cfg.distance_ingress_mm =
-            aidl_request.baseConfigs.distanceIngressCm * 10;
-    legacy_request->ranging_cfg.distance_egress_mm = aidl_request.baseConfigs.distanceEgressCm * 10;
-    legacy_request->ranging_auto_response = aidl_request.baseConfigs.rangingRequired
-                                                    ? legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE
-                                                    : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
-    legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT;
-    legacy_request->subscribe_type =
-            convertAidlNanSubscribeTypeToLegacy(aidl_request.subscribeType);
-    legacy_request->serviceResponseFilter = convertAidlNanSrfTypeToLegacy(aidl_request.srfType);
-    legacy_request->serviceResponseInclude = aidl_request.srfRespondIfInAddressSet
-                                                     ? legacy_hal::NAN_SRF_INCLUDE_RESPOND
-                                                     : legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
-    legacy_request->useServiceResponseFilter =
-            aidl_request.shouldUseSrf ? legacy_hal::NAN_USE_SRF : legacy_hal::NAN_DO_NOT_USE_SRF;
-    legacy_request->ssiRequiredForMatchIndication =
-            aidl_request.isSsiRequiredForMatch ? legacy_hal::NAN_SSI_REQUIRED_IN_MATCH_IND
-                                               : legacy_hal::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND;
-    legacy_request->num_intf_addr_present = aidl_request.intfAddr.size();
-    if (legacy_request->num_intf_addr_present > NAN_MAX_SUBSCRIBE_MAX_ADDRESS) {
-        LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
-                      "num_intf_addr_present - too many";
-        return false;
-    }
-    for (int i = 0; i < legacy_request->num_intf_addr_present; i++) {
-        memcpy(legacy_request->intf_addr[i], aidl_request.intfAddr[i].data.data(), 6);
-    }
-
-    return true;
-}
-
-bool convertAidlNanTransmitFollowupRequestToLegacy(
-        const NanTransmitFollowupRequest& aidl_request,
-        legacy_hal::NanTransmitFollowupRequest* legacy_request) {
-    if (!legacy_request) {
-        LOG(ERROR) << "convertAidlNanTransmitFollowupRequestToLegacy: "
-                      "legacy_request is null";
-        return false;
-    }
-    *legacy_request = {};
-
-    legacy_request->publish_subscribe_id = aidl_request.discoverySessionId;
-    legacy_request->requestor_instance_id = aidl_request.peerId;
-    memcpy(legacy_request->addr, aidl_request.addr.data(), 6);
-    legacy_request->priority = aidl_request.isHighPriority ? legacy_hal::NAN_TX_PRIORITY_HIGH
-                                                           : legacy_hal::NAN_TX_PRIORITY_NORMAL;
-    legacy_request->dw_or_faw = aidl_request.shouldUseDiscoveryWindow
-                                        ? legacy_hal::NAN_TRANSMIT_IN_DW
-                                        : legacy_hal::NAN_TRANSMIT_IN_FAW;
-    legacy_request->service_specific_info_len = aidl_request.serviceSpecificInfo.size();
-    if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
-        LOG(ERROR) << "convertAidlNanTransmitFollowupRequestToLegacy: "
-                      "service_specific_info_len too large";
-        return false;
-    }
-    memcpy(legacy_request->service_specific_info, aidl_request.serviceSpecificInfo.data(),
-           legacy_request->service_specific_info_len);
-    legacy_request->sdea_service_specific_info_len =
-            aidl_request.extendedServiceSpecificInfo.size();
-    if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
-        LOG(ERROR) << "convertAidlNanTransmitFollowupRequestToLegacy: "
-                      "sdea_service_specific_info_len too large";
-        return false;
-    }
-    memcpy(legacy_request->sdea_service_specific_info,
-           aidl_request.extendedServiceSpecificInfo.data(),
-           legacy_request->sdea_service_specific_info_len);
-    legacy_request->recv_indication_cfg = aidl_request.disableFollowupResultIndication ? 0x1 : 0x0;
-
-    return true;
-}
-
-bool convertAidlNanDataPathInitiatorRequestToLegacy(
-        const NanInitiateDataPathRequest& aidl_request,
-        legacy_hal::NanDataPathInitiatorRequest* legacy_request) {
-    if (!legacy_request) {
-        LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: "
-                      "legacy_request is null";
-        return false;
-    }
-    *legacy_request = {};
-
-    legacy_request->requestor_instance_id = aidl_request.peerId;
-    memcpy(legacy_request->peer_disc_mac_addr, aidl_request.peerDiscMacAddr.data(), 6);
-    legacy_request->channel_request_type =
-            convertAidlNanDataPathChannelCfgToLegacy(aidl_request.channelRequestType);
-    legacy_request->channel = aidl_request.channel;
-    if (strnlen(aidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
-        LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: "
-                      "ifaceName too long";
-        return false;
-    }
-    strlcpy(legacy_request->ndp_iface, aidl_request.ifaceName.c_str(), IFNAMSIZ + 1);
-    legacy_request->ndp_cfg.security_cfg =
-            (aidl_request.securityConfig.securityType != NanDataPathSecurityType::OPEN)
-                    ? legacy_hal::NAN_DP_CONFIG_SECURITY
-                    : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
-    legacy_request->app_info.ndp_app_info_len = aidl_request.appInfo.size();
-    if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
-        LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: "
-                      "ndp_app_info_len too large";
-        return false;
-    }
-    memcpy(legacy_request->app_info.ndp_app_info, aidl_request.appInfo.data(),
-           legacy_request->app_info.ndp_app_info_len);
-    legacy_request->cipher_type = (unsigned int)aidl_request.securityConfig.cipherType;
-    if (aidl_request.securityConfig.securityType == NanDataPathSecurityType::PMK) {
-        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
-        legacy_request->key_info.body.pmk_info.pmk_len = aidl_request.securityConfig.pmk.size();
-        if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
-            LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: "
-                          "invalid pmk_len";
-            return false;
-        }
-        memcpy(legacy_request->key_info.body.pmk_info.pmk, aidl_request.securityConfig.pmk.data(),
-               legacy_request->key_info.body.pmk_info.pmk_len);
-    }
-    if (aidl_request.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) {
-        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
-        legacy_request->key_info.body.passphrase_info.passphrase_len =
-                aidl_request.securityConfig.passphrase.size();
-        if (legacy_request->key_info.body.passphrase_info.passphrase_len <
-            NAN_SECURITY_MIN_PASSPHRASE_LEN) {
-            LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: "
-                          "passphrase_len too small";
-            return false;
-        }
-        if (legacy_request->key_info.body.passphrase_info.passphrase_len >
-            NAN_SECURITY_MAX_PASSPHRASE_LEN) {
-            LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: "
-                          "passphrase_len too large";
-            return false;
-        }
-        memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
-               aidl_request.securityConfig.passphrase.data(),
-               legacy_request->key_info.body.passphrase_info.passphrase_len);
-    }
-    legacy_request->service_name_len = aidl_request.serviceNameOutOfBand.size();
-    if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
-        LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: "
-                      "service_name_len too large";
-        return false;
-    }
-    memcpy(legacy_request->service_name, aidl_request.serviceNameOutOfBand.data(),
-           legacy_request->service_name_len);
-    legacy_request->scid_len = aidl_request.securityConfig.scid.size();
-    if (legacy_request->scid_len > NAN_MAX_SCID_BUF_LEN) {
-        LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: scid_len too large";
-        return false;
-    }
-    memcpy(legacy_request->scid, aidl_request.securityConfig.scid.data(), legacy_request->scid_len);
-
-    return true;
-}
-
-bool convertAidlNanDataPathIndicationResponseToLegacy(
-        const NanRespondToDataPathIndicationRequest& aidl_request,
-        legacy_hal::NanDataPathIndicationResponse* legacy_request) {
-    if (!legacy_request) {
-        LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: "
-                      "legacy_request is null";
-        return false;
-    }
-    *legacy_request = {};
-
-    legacy_request->rsp_code = aidl_request.acceptRequest ? legacy_hal::NAN_DP_REQUEST_ACCEPT
-                                                          : legacy_hal::NAN_DP_REQUEST_REJECT;
-    legacy_request->ndp_instance_id = aidl_request.ndpInstanceId;
-    if (strnlen(aidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
-        LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: "
-                      "ifaceName too long";
-        return false;
-    }
-    strlcpy(legacy_request->ndp_iface, aidl_request.ifaceName.c_str(), IFNAMSIZ + 1);
-    legacy_request->ndp_cfg.security_cfg =
-            (aidl_request.securityConfig.securityType != NanDataPathSecurityType::OPEN)
-                    ? legacy_hal::NAN_DP_CONFIG_SECURITY
-                    : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
-    legacy_request->app_info.ndp_app_info_len = aidl_request.appInfo.size();
-    if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
-        LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: "
-                      "ndp_app_info_len too large";
-        return false;
-    }
-    memcpy(legacy_request->app_info.ndp_app_info, aidl_request.appInfo.data(),
-           legacy_request->app_info.ndp_app_info_len);
-    legacy_request->cipher_type = (unsigned int)aidl_request.securityConfig.cipherType;
-    if (aidl_request.securityConfig.securityType == NanDataPathSecurityType::PMK) {
-        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
-        legacy_request->key_info.body.pmk_info.pmk_len = aidl_request.securityConfig.pmk.size();
-        if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
-            LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: "
-                          "invalid pmk_len";
-            return false;
-        }
-        memcpy(legacy_request->key_info.body.pmk_info.pmk, aidl_request.securityConfig.pmk.data(),
-               legacy_request->key_info.body.pmk_info.pmk_len);
-    }
-    if (aidl_request.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) {
-        legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
-        legacy_request->key_info.body.passphrase_info.passphrase_len =
-                aidl_request.securityConfig.passphrase.size();
-        if (legacy_request->key_info.body.passphrase_info.passphrase_len <
-            NAN_SECURITY_MIN_PASSPHRASE_LEN) {
-            LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: "
-                          "passphrase_len too small";
-            return false;
-        }
-        if (legacy_request->key_info.body.passphrase_info.passphrase_len >
-            NAN_SECURITY_MAX_PASSPHRASE_LEN) {
-            LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: "
-                          "passphrase_len too large";
-            return false;
-        }
-        memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
-               aidl_request.securityConfig.passphrase.data(),
-               legacy_request->key_info.body.passphrase_info.passphrase_len);
-    }
-    legacy_request->service_name_len = aidl_request.serviceNameOutOfBand.size();
-    if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
-        LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: "
-                      "service_name_len too large";
-        return false;
-    }
-    memcpy(legacy_request->service_name, aidl_request.serviceNameOutOfBand.data(),
-           legacy_request->service_name_len);
-    legacy_request->scid_len = aidl_request.securityConfig.scid.size();
-    if (legacy_request->scid_len > NAN_MAX_SCID_BUF_LEN) {
-        LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: scid_len too large";
-        return false;
-    }
-    memcpy(legacy_request->scid, aidl_request.securityConfig.scid.data(), legacy_request->scid_len);
-
-    return true;
-}
-
-bool convertLegacyNanResponseHeaderToAidl(const legacy_hal::NanResponseMsg& legacy_response,
-                                          NanStatus* nanStatus) {
-    if (!nanStatus) {
-        LOG(ERROR) << "convertLegacyNanResponseHeaderToAidl: nanStatus is null";
-        return false;
-    }
-    *nanStatus = {};
-
-    convertToNanStatus(legacy_response.status, legacy_response.nan_error,
-                       sizeof(legacy_response.nan_error), nanStatus);
-    return true;
-}
-
-bool convertLegacyNanCapabilitiesResponseToAidl(const legacy_hal::NanCapabilities& legacy_response,
-                                                NanCapabilities* aidl_response) {
-    if (!aidl_response) {
-        LOG(ERROR) << "convertLegacyNanCapabilitiesResponseToAidl: "
-                      "aidl_response is null";
-        return false;
-    }
-    *aidl_response = {};
-
-    aidl_response->maxConcurrentClusters = legacy_response.max_concurrent_nan_clusters;
-    aidl_response->maxPublishes = legacy_response.max_publishes;
-    aidl_response->maxSubscribes = legacy_response.max_subscribes;
-    aidl_response->maxServiceNameLen = legacy_response.max_service_name_len;
-    aidl_response->maxMatchFilterLen = legacy_response.max_match_filter_len;
-    aidl_response->maxTotalMatchFilterLen = legacy_response.max_total_match_filter_len;
-    aidl_response->maxServiceSpecificInfoLen = legacy_response.max_service_specific_info_len;
-    aidl_response->maxExtendedServiceSpecificInfoLen =
-            legacy_response.max_sdea_service_specific_info_len;
-    aidl_response->maxNdiInterfaces = legacy_response.max_ndi_interfaces;
-    aidl_response->maxNdpSessions = legacy_response.max_ndp_sessions;
-    aidl_response->maxAppInfoLen = legacy_response.max_app_info_len;
-    aidl_response->maxQueuedTransmitFollowupMsgs =
-            legacy_response.max_queued_transmit_followup_msgs;
-    aidl_response->maxSubscribeInterfaceAddresses = legacy_response.max_subscribe_address;
-    aidl_response->supportedCipherSuites =
-            static_cast<NanCipherSuiteType>(legacy_response.cipher_suites_supported);
-    aidl_response->instantCommunicationModeSupportFlag = legacy_response.is_instant_mode_supported;
-
-    return true;
-}
-
-bool convertLegacyNanMatchIndToAidl(const legacy_hal::NanMatchInd& legacy_ind,
-                                    NanMatchInd* aidl_ind) {
-    if (!aidl_ind) {
-        LOG(ERROR) << "convertLegacyNanMatchIndToAidl: aidl_ind is null";
-        return false;
-    }
-    *aidl_ind = {};
-
-    aidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
-    aidl_ind->peerId = legacy_ind.requestor_instance_id;
-    aidl_ind->addr = std::array<uint8_t, 6>();
-    std::copy(legacy_ind.addr, legacy_ind.addr + 6, std::begin(aidl_ind->addr));
-    aidl_ind->serviceSpecificInfo = std::vector<uint8_t>(
-            legacy_ind.service_specific_info,
-            legacy_ind.service_specific_info + legacy_ind.service_specific_info_len);
-    aidl_ind->extendedServiceSpecificInfo = std::vector<uint8_t>(
-            legacy_ind.sdea_service_specific_info,
-            legacy_ind.sdea_service_specific_info + legacy_ind.sdea_service_specific_info_len);
-    aidl_ind->matchFilter =
-            std::vector<uint8_t>(legacy_ind.sdf_match_filter,
-                                 legacy_ind.sdf_match_filter + legacy_ind.sdf_match_filter_len);
-    aidl_ind->matchOccurredInBeaconFlag = legacy_ind.match_occured_flag == 1;  // NOTYPO
-    aidl_ind->outOfResourceFlag = legacy_ind.out_of_resource_flag == 1;
-    aidl_ind->rssiValue = legacy_ind.rssi_value;
-    aidl_ind->peerCipherType = (NanCipherSuiteType)legacy_ind.peer_cipher_type;
-    aidl_ind->peerRequiresSecurityEnabledInNdp =
-            legacy_ind.peer_sdea_params.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
-    aidl_ind->peerRequiresRanging =
-            legacy_ind.peer_sdea_params.ranging_state == legacy_hal::NAN_RANGING_ENABLE;
-    aidl_ind->rangingMeasurementInMm = legacy_ind.range_info.range_measurement_mm;
-    aidl_ind->rangingIndicationType =
-            static_cast<NanRangingIndication>(legacy_ind.range_info.ranging_event_type);
-    aidl_ind->scid = std::vector<uint8_t>(legacy_ind.scid, legacy_ind.scid + legacy_ind.scid_len);
-    return true;
-}
-
-bool convertLegacyNanFollowupIndToAidl(const legacy_hal::NanFollowupInd& legacy_ind,
-                                       NanFollowupReceivedInd* aidl_ind) {
-    if (!aidl_ind) {
-        LOG(ERROR) << "convertLegacyNanFollowupIndToAidl: aidl_ind is null";
-        return false;
-    }
-    *aidl_ind = {};
-
-    aidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
-    aidl_ind->peerId = legacy_ind.requestor_instance_id;
-    aidl_ind->addr = std::array<uint8_t, 6>();
-    std::copy(legacy_ind.addr, legacy_ind.addr + 6, std::begin(aidl_ind->addr));
-    aidl_ind->receivedInFaw = legacy_ind.dw_or_faw == 1;
-    aidl_ind->serviceSpecificInfo = std::vector<uint8_t>(
-            legacy_ind.service_specific_info,
-            legacy_ind.service_specific_info + legacy_ind.service_specific_info_len);
-    aidl_ind->extendedServiceSpecificInfo = std::vector<uint8_t>(
-            legacy_ind.sdea_service_specific_info,
-            legacy_ind.sdea_service_specific_info + legacy_ind.sdea_service_specific_info_len);
-
-    return true;
-}
-
-bool convertLegacyNanDataPathRequestIndToAidl(const legacy_hal::NanDataPathRequestInd& legacy_ind,
-                                              NanDataPathRequestInd* aidl_ind) {
-    if (!aidl_ind) {
-        LOG(ERROR) << "convertLegacyNanDataPathRequestIndToAidl: aidl_ind is null";
-        return false;
-    }
-    *aidl_ind = {};
-
-    aidl_ind->discoverySessionId = legacy_ind.service_instance_id;
-    aidl_ind->peerDiscMacAddr = std::array<uint8_t, 6>();
-    std::copy(legacy_ind.peer_disc_mac_addr, legacy_ind.peer_disc_mac_addr + 6,
-              std::begin(aidl_ind->peerDiscMacAddr));
-    aidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
-    aidl_ind->securityRequired =
-            legacy_ind.ndp_cfg.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
-    aidl_ind->appInfo = std::vector<uint8_t>(
-            legacy_ind.app_info.ndp_app_info,
-            legacy_ind.app_info.ndp_app_info + legacy_ind.app_info.ndp_app_info_len);
-
-    return true;
-}
-
-bool convertLegacyNdpChannelInfoToAidl(const legacy_hal::NanChannelInfo& legacy_struct,
-                                       NanDataPathChannelInfo* aidl_struct) {
-    if (!aidl_struct) {
-        LOG(ERROR) << "convertLegacyNdpChannelInfoToAidl: aidl_struct is null";
-        return false;
-    }
-    *aidl_struct = {};
-
-    aidl_struct->channelFreq = legacy_struct.channel;
-    aidl_struct->channelBandwidth = convertLegacyWifiChannelWidthToAidl(
-            (legacy_hal::wifi_channel_width)legacy_struct.bandwidth);
-    aidl_struct->numSpatialStreams = legacy_struct.nss;
-
-    return true;
-}
-
-bool convertLegacyNanDataPathConfirmIndToAidl(const legacy_hal::NanDataPathConfirmInd& legacy_ind,
-                                              NanDataPathConfirmInd* aidl_ind) {
-    if (!aidl_ind) {
-        LOG(ERROR) << "convertLegacyNanDataPathConfirmIndToAidl: aidl_ind is null";
-        return false;
-    }
-    *aidl_ind = {};
-
-    aidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
-    aidl_ind->dataPathSetupSuccess = legacy_ind.rsp_code == legacy_hal::NAN_DP_REQUEST_ACCEPT;
-    aidl_ind->peerNdiMacAddr = std::array<uint8_t, 6>();
-    std::copy(legacy_ind.peer_ndi_mac_addr, legacy_ind.peer_ndi_mac_addr + 6,
-              std::begin(aidl_ind->peerNdiMacAddr));
-    aidl_ind->appInfo = std::vector<uint8_t>(
-            legacy_ind.app_info.ndp_app_info,
-            legacy_ind.app_info.ndp_app_info + legacy_ind.app_info.ndp_app_info_len);
-    aidl_ind->status.status = convertLegacyNanStatusTypeToAidl(legacy_ind.reason_code);
-    aidl_ind->status.description = "";
-
-    std::vector<NanDataPathChannelInfo> channelInfo;
-    for (unsigned int i = 0; i < legacy_ind.num_channels; ++i) {
-        NanDataPathChannelInfo aidl_struct;
-        if (!convertLegacyNdpChannelInfoToAidl(legacy_ind.channel_info[i], &aidl_struct)) {
-            return false;
-        }
-        channelInfo.push_back(aidl_struct);
-    }
-    aidl_ind->channelInfo = channelInfo;
-
-    return true;
-}
-
-bool convertLegacyNanDataPathScheduleUpdateIndToAidl(
-        const legacy_hal::NanDataPathScheduleUpdateInd& legacy_ind,
-        NanDataPathScheduleUpdateInd* aidl_ind) {
-    if (!aidl_ind) {
-        LOG(ERROR) << "convertLegacyNanDataPathScheduleUpdateIndToAidl: "
-                      "aidl_ind is null";
-        return false;
-    }
-    *aidl_ind = {};
-
-    aidl_ind->peerDiscoveryAddress = std::array<uint8_t, 6>();
-    std::copy(legacy_ind.peer_mac_addr, legacy_ind.peer_mac_addr + 6,
-              std::begin(aidl_ind->peerDiscoveryAddress));
-    std::vector<NanDataPathChannelInfo> channelInfo;
-    for (unsigned int i = 0; i < legacy_ind.num_channels; ++i) {
-        NanDataPathChannelInfo aidl_struct;
-        if (!convertLegacyNdpChannelInfoToAidl(legacy_ind.channel_info[i], &aidl_struct)) {
-            return false;
-        }
-        channelInfo.push_back(aidl_struct);
-    }
-    aidl_ind->channelInfo = channelInfo;
-    std::vector<uint32_t> ndpInstanceIds;
-    for (unsigned int i = 0; i < legacy_ind.num_ndp_instances; ++i) {
-        ndpInstanceIds.push_back(legacy_ind.ndp_instance_id[i]);
-    }
-    aidl_ind->ndpInstanceIds = uintToIntVec(ndpInstanceIds);
-
-    return true;
-}
-
-legacy_hal::wifi_rtt_type convertAidlRttTypeToLegacy(RttType type) {
-    switch (type) {
-        case RttType::ONE_SIDED:
-            return legacy_hal::RTT_TYPE_1_SIDED;
-        case RttType::TWO_SIDED:
-            return legacy_hal::RTT_TYPE_2_SIDED;
-    };
-    CHECK(false);
-}
-
-RttType convertLegacyRttTypeToAidl(legacy_hal::wifi_rtt_type type) {
-    switch (type) {
-        case legacy_hal::RTT_TYPE_1_SIDED:
-            return RttType::ONE_SIDED;
-        case legacy_hal::RTT_TYPE_2_SIDED:
-            return RttType::TWO_SIDED;
-    };
-    CHECK(false) << "Unknown legacy type: " << type;
-}
-
-legacy_hal::rtt_peer_type convertAidlRttPeerTypeToLegacy(RttPeerType type) {
-    switch (type) {
-        case RttPeerType::AP:
-            return legacy_hal::RTT_PEER_AP;
-        case RttPeerType::STA:
-            return legacy_hal::RTT_PEER_STA;
-        case RttPeerType::P2P_GO:
-            return legacy_hal::RTT_PEER_P2P_GO;
-        case RttPeerType::P2P_CLIENT:
-            return legacy_hal::RTT_PEER_P2P_CLIENT;
-        case RttPeerType::NAN_TYPE:
-            return legacy_hal::RTT_PEER_NAN;
-    };
-    CHECK(false);
-}
-
-legacy_hal::wifi_channel_width convertAidlWifiChannelWidthToLegacy(WifiChannelWidthInMhz type) {
-    switch (type) {
-        case WifiChannelWidthInMhz::WIDTH_20:
-            return legacy_hal::WIFI_CHAN_WIDTH_20;
-        case WifiChannelWidthInMhz::WIDTH_40:
-            return legacy_hal::WIFI_CHAN_WIDTH_40;
-        case WifiChannelWidthInMhz::WIDTH_80:
-            return legacy_hal::WIFI_CHAN_WIDTH_80;
-        case WifiChannelWidthInMhz::WIDTH_160:
-            return legacy_hal::WIFI_CHAN_WIDTH_160;
-        case WifiChannelWidthInMhz::WIDTH_80P80:
-            return legacy_hal::WIFI_CHAN_WIDTH_80P80;
-        case WifiChannelWidthInMhz::WIDTH_5:
-            return legacy_hal::WIFI_CHAN_WIDTH_5;
-        case WifiChannelWidthInMhz::WIDTH_10:
-            return legacy_hal::WIFI_CHAN_WIDTH_10;
-        case WifiChannelWidthInMhz::WIDTH_320:
-            return legacy_hal::WIFI_CHAN_WIDTH_320;
-        case WifiChannelWidthInMhz::WIDTH_INVALID:
-            return legacy_hal::WIFI_CHAN_WIDTH_INVALID;
-    };
-    CHECK(false);
-}
-
-WifiChannelWidthInMhz convertLegacyWifiChannelWidthToAidl(legacy_hal::wifi_channel_width type) {
-    switch (type) {
-        case legacy_hal::WIFI_CHAN_WIDTH_20:
-            return WifiChannelWidthInMhz::WIDTH_20;
-        case legacy_hal::WIFI_CHAN_WIDTH_40:
-            return WifiChannelWidthInMhz::WIDTH_40;
-        case legacy_hal::WIFI_CHAN_WIDTH_80:
-            return WifiChannelWidthInMhz::WIDTH_80;
-        case legacy_hal::WIFI_CHAN_WIDTH_160:
-            return WifiChannelWidthInMhz::WIDTH_160;
-        case legacy_hal::WIFI_CHAN_WIDTH_80P80:
-            return WifiChannelWidthInMhz::WIDTH_80P80;
-        case legacy_hal::WIFI_CHAN_WIDTH_5:
-            return WifiChannelWidthInMhz::WIDTH_5;
-        case legacy_hal::WIFI_CHAN_WIDTH_10:
-            return WifiChannelWidthInMhz::WIDTH_10;
-        case legacy_hal::WIFI_CHAN_WIDTH_320:
-            return WifiChannelWidthInMhz::WIDTH_320;
-        default:
-            return WifiChannelWidthInMhz::WIDTH_INVALID;
-    };
-}
-
-legacy_hal::wifi_rtt_preamble convertAidlRttPreambleToLegacy(RttPreamble type) {
-    switch (type) {
-        case RttPreamble::LEGACY:
-            return legacy_hal::WIFI_RTT_PREAMBLE_LEGACY;
-        case RttPreamble::HT:
-            return legacy_hal::WIFI_RTT_PREAMBLE_HT;
-        case RttPreamble::VHT:
-            return legacy_hal::WIFI_RTT_PREAMBLE_VHT;
-        case RttPreamble::HE:
-            return legacy_hal::WIFI_RTT_PREAMBLE_HE;
-        case RttPreamble::EHT:
-            return legacy_hal::WIFI_RTT_PREAMBLE_EHT;
-    };
-    CHECK(false);
-}
-
-RttPreamble convertLegacyRttPreambleToAidl(legacy_hal::wifi_rtt_preamble type) {
-    switch (type) {
-        case legacy_hal::WIFI_RTT_PREAMBLE_LEGACY:
-            return RttPreamble::LEGACY;
-        case legacy_hal::WIFI_RTT_PREAMBLE_HT:
-            return RttPreamble::HT;
-        case legacy_hal::WIFI_RTT_PREAMBLE_VHT:
-            return RttPreamble::VHT;
-        case legacy_hal::WIFI_RTT_PREAMBLE_HE:
-            return RttPreamble::HE;
-        case legacy_hal::WIFI_RTT_PREAMBLE_EHT:
-            return RttPreamble::EHT;
-    };
-    CHECK(false) << "Unknown legacy type: " << type;
-}
-
-legacy_hal::wifi_rtt_bw convertAidlRttBwToLegacy(RttBw type) {
-    switch (type) {
-        case RttBw::BW_5MHZ:
-            return legacy_hal::WIFI_RTT_BW_5;
-        case RttBw::BW_10MHZ:
-            return legacy_hal::WIFI_RTT_BW_10;
-        case RttBw::BW_20MHZ:
-            return legacy_hal::WIFI_RTT_BW_20;
-        case RttBw::BW_40MHZ:
-            return legacy_hal::WIFI_RTT_BW_40;
-        case RttBw::BW_80MHZ:
-            return legacy_hal::WIFI_RTT_BW_80;
-        case RttBw::BW_160MHZ:
-            return legacy_hal::WIFI_RTT_BW_160;
-        case RttBw::BW_320MHZ:
-            return legacy_hal::WIFI_RTT_BW_320;
-    };
-    CHECK(false);
-}
-
-RttBw convertLegacyRttBwToAidl(legacy_hal::wifi_rtt_bw type) {
-    switch (type) {
-        case legacy_hal::WIFI_RTT_BW_5:
-            return RttBw::BW_5MHZ;
-        case legacy_hal::WIFI_RTT_BW_10:
-            return RttBw::BW_10MHZ;
-        case legacy_hal::WIFI_RTT_BW_20:
-            return RttBw::BW_20MHZ;
-        case legacy_hal::WIFI_RTT_BW_40:
-            return RttBw::BW_40MHZ;
-        case legacy_hal::WIFI_RTT_BW_80:
-            return RttBw::BW_80MHZ;
-        case legacy_hal::WIFI_RTT_BW_160:
-            return RttBw::BW_160MHZ;
-        case legacy_hal::WIFI_RTT_BW_320:
-            return RttBw::BW_320MHZ;
-    };
-    CHECK(false) << "Unknown legacy type: " << type;
-}
-
-legacy_hal::wifi_motion_pattern convertAidlRttMotionPatternToLegacy(RttMotionPattern type) {
-    switch (type) {
-        case RttMotionPattern::NOT_EXPECTED:
-            return legacy_hal::WIFI_MOTION_NOT_EXPECTED;
-        case RttMotionPattern::EXPECTED:
-            return legacy_hal::WIFI_MOTION_EXPECTED;
-        case RttMotionPattern::UNKNOWN:
-            return legacy_hal::WIFI_MOTION_UNKNOWN;
-    };
-    CHECK(false);
-}
-
-WifiRatePreamble convertLegacyWifiRatePreambleToAidl(uint8_t preamble) {
-    switch (preamble) {
-        case 0:
-            return WifiRatePreamble::OFDM;
-        case 1:
-            return WifiRatePreamble::CCK;
-        case 2:
-            return WifiRatePreamble::HT;
-        case 3:
-            return WifiRatePreamble::VHT;
-        case 4:
-            return WifiRatePreamble::HE;
-        case 5:
-            return WifiRatePreamble::EHT;
-        default:
-            return WifiRatePreamble::RESERVED;
-    };
-    CHECK(false) << "Unknown legacy preamble: " << preamble;
-}
-
-WifiRateNss convertLegacyWifiRateNssToAidl(uint8_t nss) {
-    switch (nss) {
-        case 0:
-            return WifiRateNss::NSS_1x1;
-        case 1:
-            return WifiRateNss::NSS_2x2;
-        case 2:
-            return WifiRateNss::NSS_3x3;
-        case 3:
-            return WifiRateNss::NSS_4x4;
-    };
-    CHECK(false) << "Unknown legacy nss: " << nss;
-    return {};
-}
-
-RttStatus convertLegacyRttStatusToAidl(legacy_hal::wifi_rtt_status status) {
-    switch (status) {
-        case legacy_hal::RTT_STATUS_SUCCESS:
-            return RttStatus::SUCCESS;
-        case legacy_hal::RTT_STATUS_FAILURE:
-            return RttStatus::FAILURE;
-        case legacy_hal::RTT_STATUS_FAIL_NO_RSP:
-            return RttStatus::FAIL_NO_RSP;
-        case legacy_hal::RTT_STATUS_FAIL_REJECTED:
-            return RttStatus::FAIL_REJECTED;
-        case legacy_hal::RTT_STATUS_FAIL_NOT_SCHEDULED_YET:
-            return RttStatus::FAIL_NOT_SCHEDULED_YET;
-        case legacy_hal::RTT_STATUS_FAIL_TM_TIMEOUT:
-            return RttStatus::FAIL_TM_TIMEOUT;
-        case legacy_hal::RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL:
-            return RttStatus::FAIL_AP_ON_DIFF_CHANNEL;
-        case legacy_hal::RTT_STATUS_FAIL_NO_CAPABILITY:
-            return RttStatus::FAIL_NO_CAPABILITY;
-        case legacy_hal::RTT_STATUS_ABORTED:
-            return RttStatus::ABORTED;
-        case legacy_hal::RTT_STATUS_FAIL_INVALID_TS:
-            return RttStatus::FAIL_INVALID_TS;
-        case legacy_hal::RTT_STATUS_FAIL_PROTOCOL:
-            return RttStatus::FAIL_PROTOCOL;
-        case legacy_hal::RTT_STATUS_FAIL_SCHEDULE:
-            return RttStatus::FAIL_SCHEDULE;
-        case legacy_hal::RTT_STATUS_FAIL_BUSY_TRY_LATER:
-            return RttStatus::FAIL_BUSY_TRY_LATER;
-        case legacy_hal::RTT_STATUS_INVALID_REQ:
-            return RttStatus::INVALID_REQ;
-        case legacy_hal::RTT_STATUS_NO_WIFI:
-            return RttStatus::NO_WIFI;
-        case legacy_hal::RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE:
-            return RttStatus::FAIL_FTM_PARAM_OVERRIDE;
-        case legacy_hal::RTT_STATUS_NAN_RANGING_PROTOCOL_FAILURE:
-            return RttStatus::NAN_RANGING_PROTOCOL_FAILURE;
-        case legacy_hal::RTT_STATUS_NAN_RANGING_CONCURRENCY_NOT_SUPPORTED:
-            return RttStatus::NAN_RANGING_CONCURRENCY_NOT_SUPPORTED;
-    };
-    CHECK(false) << "Unknown legacy status: " << status;
-}
-
-bool convertAidlWifiChannelInfoToLegacy(const WifiChannelInfo& aidl_info,
-                                        legacy_hal::wifi_channel_info* legacy_info) {
-    if (!legacy_info) {
-        return false;
-    }
-    *legacy_info = {};
-    legacy_info->width = convertAidlWifiChannelWidthToLegacy(aidl_info.width);
-    legacy_info->center_freq = aidl_info.centerFreq;
-    legacy_info->center_freq0 = aidl_info.centerFreq0;
-    legacy_info->center_freq1 = aidl_info.centerFreq1;
-    return true;
-}
-
-bool convertLegacyWifiChannelInfoToAidl(const legacy_hal::wifi_channel_info& legacy_info,
-                                        WifiChannelInfo* aidl_info) {
-    if (!aidl_info) {
-        return false;
-    }
-    *aidl_info = {};
-    aidl_info->width = convertLegacyWifiChannelWidthToAidl(legacy_info.width);
-    aidl_info->centerFreq = legacy_info.center_freq;
-    aidl_info->centerFreq0 = legacy_info.center_freq0;
-    aidl_info->centerFreq1 = legacy_info.center_freq1;
-    return true;
-}
-
-bool convertAidlRttConfigToLegacy(const RttConfig& aidl_config,
-                                  legacy_hal::wifi_rtt_config* legacy_config) {
-    if (!legacy_config) {
-        return false;
-    }
-    *legacy_config = {};
-    CHECK(aidl_config.addr.size() == sizeof(legacy_config->addr));
-    memcpy(legacy_config->addr, aidl_config.addr.data(), aidl_config.addr.size());
-    legacy_config->type = convertAidlRttTypeToLegacy(aidl_config.type);
-    legacy_config->peer = convertAidlRttPeerTypeToLegacy(aidl_config.peer);
-    if (!convertAidlWifiChannelInfoToLegacy(aidl_config.channel, &legacy_config->channel)) {
-        return false;
-    }
-    legacy_config->burst_period = aidl_config.burstPeriod;
-    legacy_config->num_burst = aidl_config.numBurst;
-    legacy_config->num_frames_per_burst = aidl_config.numFramesPerBurst;
-    legacy_config->num_retries_per_rtt_frame = aidl_config.numRetriesPerRttFrame;
-    legacy_config->num_retries_per_ftmr = aidl_config.numRetriesPerFtmr;
-    legacy_config->LCI_request = aidl_config.mustRequestLci;
-    legacy_config->LCR_request = aidl_config.mustRequestLcr;
-    legacy_config->burst_duration = aidl_config.burstDuration;
-    legacy_config->preamble = convertAidlRttPreambleToLegacy(aidl_config.preamble);
-    legacy_config->bw = convertAidlRttBwToLegacy(aidl_config.bw);
-    return true;
-}
-
-bool convertAidlVectorOfRttConfigToLegacy(
-        const std::vector<RttConfig>& aidl_configs,
-        std::vector<legacy_hal::wifi_rtt_config>* legacy_configs) {
-    if (!legacy_configs) {
-        return false;
-    }
-    *legacy_configs = {};
-    for (const auto& aidl_config : aidl_configs) {
-        legacy_hal::wifi_rtt_config legacy_config;
-        if (!convertAidlRttConfigToLegacy(aidl_config, &legacy_config)) {
-            return false;
-        }
-        legacy_configs->push_back(legacy_config);
-    }
-    return true;
-}
-
-bool convertAidlRttLciInformationToLegacy(const RttLciInformation& aidl_info,
-                                          legacy_hal::wifi_lci_information* legacy_info) {
-    if (!legacy_info) {
-        return false;
-    }
-    *legacy_info = {};
-    legacy_info->latitude = aidl_info.latitude;
-    legacy_info->longitude = aidl_info.longitude;
-    legacy_info->altitude = aidl_info.altitude;
-    legacy_info->latitude_unc = aidl_info.latitudeUnc;
-    legacy_info->longitude_unc = aidl_info.longitudeUnc;
-    legacy_info->altitude_unc = aidl_info.altitudeUnc;
-    legacy_info->motion_pattern = convertAidlRttMotionPatternToLegacy(aidl_info.motionPattern);
-    legacy_info->floor = aidl_info.floor;
-    legacy_info->height_above_floor = aidl_info.heightAboveFloor;
-    legacy_info->height_unc = aidl_info.heightUnc;
-    return true;
-}
-
-bool convertAidlRttLcrInformationToLegacy(const RttLcrInformation& aidl_info,
-                                          legacy_hal::wifi_lcr_information* legacy_info) {
-    if (!legacy_info) {
-        return false;
-    }
-    *legacy_info = {};
-    CHECK(aidl_info.countryCode.size() == sizeof(legacy_info->country_code));
-    memcpy(legacy_info->country_code, aidl_info.countryCode.data(), aidl_info.countryCode.size());
-    if (aidl_info.civicInfo.size() > sizeof(legacy_info->civic_info)) {
-        return false;
-    }
-    legacy_info->length = aidl_info.civicInfo.size();
-    memcpy(legacy_info->civic_info, aidl_info.civicInfo.c_str(), aidl_info.civicInfo.size());
-    return true;
-}
-
-bool convertAidlRttResponderToLegacy(const RttResponder& aidl_responder,
-                                     legacy_hal::wifi_rtt_responder* legacy_responder) {
-    if (!legacy_responder) {
-        return false;
-    }
-    *legacy_responder = {};
-    if (!convertAidlWifiChannelInfoToLegacy(aidl_responder.channel, &legacy_responder->channel)) {
-        return false;
-    }
-    legacy_responder->preamble = convertAidlRttPreambleToLegacy(aidl_responder.preamble);
-    return true;
-}
-
-bool convertLegacyRttResponderToAidl(const legacy_hal::wifi_rtt_responder& legacy_responder,
-                                     RttResponder* aidl_responder) {
-    if (!aidl_responder) {
-        return false;
-    }
-    *aidl_responder = {};
-    if (!convertLegacyWifiChannelInfoToAidl(legacy_responder.channel, &aidl_responder->channel)) {
-        return false;
-    }
-    aidl_responder->preamble = convertLegacyRttPreambleToAidl(legacy_responder.preamble);
-    return true;
-}
-
-bool convertLegacyRttCapabilitiesToAidl(
-        const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
-        RttCapabilities* aidl_capabilities) {
-    if (!aidl_capabilities) {
-        return false;
-    }
-    *aidl_capabilities = {};
-    aidl_capabilities->rttOneSidedSupported = legacy_capabilities.rtt_one_sided_supported;
-    aidl_capabilities->rttFtmSupported = legacy_capabilities.rtt_ftm_supported;
-    aidl_capabilities->lciSupported = legacy_capabilities.lci_support;
-    aidl_capabilities->lcrSupported = legacy_capabilities.lcr_support;
-    aidl_capabilities->responderSupported = legacy_capabilities.responder_supported;
-    int32_t preambleSupport = 0;
-    for (const auto flag : {legacy_hal::WIFI_RTT_PREAMBLE_LEGACY, legacy_hal::WIFI_RTT_PREAMBLE_HT,
-                            legacy_hal::WIFI_RTT_PREAMBLE_VHT, legacy_hal::WIFI_RTT_PREAMBLE_HE,
-                            legacy_hal::WIFI_RTT_PREAMBLE_EHT}) {
-        if (legacy_capabilities.preamble_support & flag) {
-            preambleSupport |= static_cast<std::underlying_type<RttPreamble>::type>(
-                    convertLegacyRttPreambleToAidl(flag));
-        }
-    }
-    aidl_capabilities->preambleSupport = static_cast<RttPreamble>(preambleSupport);
-    int32_t bwSupport = 0;
-    for (const auto flag :
-         {legacy_hal::WIFI_RTT_BW_5, legacy_hal::WIFI_RTT_BW_10, legacy_hal::WIFI_RTT_BW_20,
-          legacy_hal::WIFI_RTT_BW_40, legacy_hal::WIFI_RTT_BW_80, legacy_hal::WIFI_RTT_BW_160,
-          legacy_hal::WIFI_RTT_BW_320}) {
-        if (legacy_capabilities.bw_support & flag) {
-            bwSupport |=
-                    static_cast<std::underlying_type<RttBw>::type>(convertLegacyRttBwToAidl(flag));
-        }
-    }
-    aidl_capabilities->bwSupport = static_cast<RttBw>(bwSupport);
-    aidl_capabilities->mcVersion = legacy_capabilities.mc_version;
-    return true;
-}
-
-bool convertLegacyWifiRateInfoToAidl(const legacy_hal::wifi_rate& legacy_rate,
-                                     WifiRateInfo* aidl_rate) {
-    if (!aidl_rate) {
-        return false;
-    }
-    *aidl_rate = {};
-    aidl_rate->preamble = convertLegacyWifiRatePreambleToAidl(legacy_rate.preamble);
-    aidl_rate->nss = convertLegacyWifiRateNssToAidl(legacy_rate.nss);
-    aidl_rate->bw = convertLegacyWifiChannelWidthToAidl(
-            static_cast<legacy_hal::wifi_channel_width>(legacy_rate.bw));
-    aidl_rate->rateMcsIdx = legacy_rate.rateMcsIdx;
-    aidl_rate->bitRateInKbps = legacy_rate.bitrate;
-    return true;
-}
-
-bool convertLegacyRttResultToAidl(const legacy_hal::wifi_rtt_result& legacy_result,
-                                  RttResult* aidl_result) {
-    if (!aidl_result) {
-        return false;
-    }
-    *aidl_result = {};
-    aidl_result->addr = std::array<uint8_t, 6>();
-    CHECK(sizeof(legacy_result.addr) == aidl_result->addr.size());
-    std::copy(legacy_result.addr, legacy_result.addr + 6, std::begin(aidl_result->addr));
-    aidl_result->burstNum = legacy_result.burst_num;
-    aidl_result->measurementNumber = legacy_result.measurement_number;
-    aidl_result->successNumber = legacy_result.success_number;
-    aidl_result->numberPerBurstPeer = legacy_result.number_per_burst_peer;
-    aidl_result->status = convertLegacyRttStatusToAidl(legacy_result.status);
-    aidl_result->retryAfterDuration = legacy_result.retry_after_duration;
-    aidl_result->type = convertLegacyRttTypeToAidl(legacy_result.type);
-    aidl_result->rssi = legacy_result.rssi;
-    aidl_result->rssiSpread = legacy_result.rssi_spread;
-    if (!convertLegacyWifiRateInfoToAidl(legacy_result.tx_rate, &aidl_result->txRate)) {
-        return false;
-    }
-    if (!convertLegacyWifiRateInfoToAidl(legacy_result.rx_rate, &aidl_result->rxRate)) {
-        return false;
-    }
-    aidl_result->rtt = legacy_result.rtt;
-    aidl_result->rttSd = legacy_result.rtt_sd;
-    aidl_result->rttSpread = legacy_result.rtt_spread;
-    aidl_result->distanceInMm = legacy_result.distance_mm;
-    aidl_result->distanceSdInMm = legacy_result.distance_sd_mm;
-    aidl_result->distanceSpreadInMm = legacy_result.distance_spread_mm;
-    aidl_result->timeStampInUs = legacy_result.ts;
-    aidl_result->burstDurationInMs = legacy_result.burst_duration;
-    aidl_result->negotiatedBurstNum = legacy_result.negotiated_burst_num;
-    if (legacy_result.LCI && !convertLegacyIeToAidl(*legacy_result.LCI, &aidl_result->lci)) {
-        return false;
-    }
-    if (legacy_result.LCR && !convertLegacyIeToAidl(*legacy_result.LCR, &aidl_result->lcr)) {
-        return false;
-    }
-    return true;
-}
-
-bool convertLegacyVectorOfRttResultToAidl(
-        const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
-        std::vector<RttResult>* aidl_results) {
-    if (!aidl_results) {
-        return false;
-    }
-    *aidl_results = {};
-    for (const auto legacy_result : legacy_results) {
-        RttResult aidl_result;
-        if (!convertLegacyRttResultToAidl(*legacy_result, &aidl_result)) {
-            return false;
-        }
-        aidl_results->push_back(aidl_result);
-    }
-    return true;
-}
-
-legacy_hal::wifi_interface_type convertAidlIfaceTypeToLegacy(IfaceType aidl_interface_type) {
-    switch (aidl_interface_type) {
-        case IfaceType::STA:
-            return legacy_hal::WIFI_INTERFACE_TYPE_STA;
-        case IfaceType::AP:
-            return legacy_hal::WIFI_INTERFACE_TYPE_AP;
-        case IfaceType::P2P:
-            return legacy_hal::WIFI_INTERFACE_TYPE_P2P;
-        case IfaceType::NAN_IFACE:
-            return legacy_hal::WIFI_INTERFACE_TYPE_NAN;
-    }
-    CHECK(false);
-}
-
-legacy_hal::wifi_multi_sta_use_case convertAidlMultiStaUseCaseToLegacy(
-        IWifiChip::MultiStaUseCase use_case) {
-    switch (use_case) {
-        case IWifiChip::MultiStaUseCase::DUAL_STA_TRANSIENT_PREFER_PRIMARY:
-            return legacy_hal::WIFI_DUAL_STA_TRANSIENT_PREFER_PRIMARY;
-        case IWifiChip::MultiStaUseCase::DUAL_STA_NON_TRANSIENT_UNBIASED:
-            return legacy_hal::WIFI_DUAL_STA_NON_TRANSIENT_UNBIASED;
-    }
-    CHECK(false);
-}
-
-bool convertAidlCoexUnsafeChannelToLegacy(
-        const IWifiChip::CoexUnsafeChannel& aidl_unsafe_channel,
-        legacy_hal::wifi_coex_unsafe_channel* legacy_unsafe_channel) {
-    if (!legacy_unsafe_channel) {
-        return false;
-    }
-    *legacy_unsafe_channel = {};
-    switch (aidl_unsafe_channel.band) {
-        case WifiBand::BAND_24GHZ:
-            legacy_unsafe_channel->band = legacy_hal::WLAN_MAC_2_4_BAND;
-            break;
-        case WifiBand::BAND_5GHZ:
-            legacy_unsafe_channel->band = legacy_hal::WLAN_MAC_5_0_BAND;
-            break;
-        default:
-            return false;
-    };
-    legacy_unsafe_channel->channel = aidl_unsafe_channel.channel;
-    legacy_unsafe_channel->power_cap_dbm = aidl_unsafe_channel.powerCapDbm;
-    return true;
-}
-
-bool convertAidlVectorOfCoexUnsafeChannelToLegacy(
-        const std::vector<IWifiChip::CoexUnsafeChannel>& aidl_unsafe_channels,
-        std::vector<legacy_hal::wifi_coex_unsafe_channel>* legacy_unsafe_channels) {
-    if (!legacy_unsafe_channels) {
-        return false;
-    }
-    *legacy_unsafe_channels = {};
-    for (const auto& aidl_unsafe_channel : aidl_unsafe_channels) {
-        legacy_hal::wifi_coex_unsafe_channel legacy_unsafe_channel;
-        if (!aidl_struct_util::convertAidlCoexUnsafeChannelToLegacy(aidl_unsafe_channel,
-                                                                    &legacy_unsafe_channel)) {
-            return false;
-        }
-        legacy_unsafe_channels->push_back(legacy_unsafe_channel);
-    }
-    return true;
-}
-
-WifiAntennaMode convertLegacyAntennaConfigurationToAidl(uint32_t antenna_cfg) {
-    switch (antenna_cfg) {
-        case legacy_hal::WIFI_ANTENNA_1X1:
-            return WifiAntennaMode::WIFI_ANTENNA_MODE_1X1;
-        case legacy_hal::WIFI_ANTENNA_2X2:
-            return WifiAntennaMode::WIFI_ANTENNA_MODE_2X2;
-        case legacy_hal::WIFI_ANTENNA_3X3:
-            return WifiAntennaMode::WIFI_ANTENNA_MODE_3X3;
-        case legacy_hal::WIFI_ANTENNA_4X4:
-            return WifiAntennaMode::WIFI_ANTENNA_MODE_4X4;
-        default:
-            return WifiAntennaMode::WIFI_ANTENNA_MODE_UNSPECIFIED;
-    }
-}
-
-bool convertLegacyWifiRadioConfigurationToAidl(
-        legacy_hal::wifi_radio_configuration* radio_configuration,
-        WifiRadioConfiguration* aidl_radio_configuration) {
-    if (!aidl_radio_configuration) {
-        return false;
-    }
-    *aidl_radio_configuration = {};
-    aidl_radio_configuration->bandInfo =
-            aidl_struct_util::convertLegacyMacBandToAidlWifiBand(radio_configuration->band);
-    if (aidl_radio_configuration->bandInfo == WifiBand::BAND_UNSPECIFIED) {
-        LOG(ERROR) << "Unspecified band";
-        return false;
-    }
-    aidl_radio_configuration->antennaMode =
-            aidl_struct_util::convertLegacyAntennaConfigurationToAidl(
-                    radio_configuration->antenna_cfg);
-    return true;
-}
-
-bool convertLegacyRadioCombinationsMatrixToAidl(
-        legacy_hal::wifi_radio_combination_matrix* legacy_matrix,
-        WifiRadioCombinationMatrix* aidl_matrix) {
-    if (!aidl_matrix || !legacy_matrix) {
-        return false;
-    }
-    *aidl_matrix = {};
-
-    int num_combinations = legacy_matrix->num_radio_combinations;
-    std::vector<WifiRadioCombination> radio_combinations_vec;
-    if (!num_combinations) {
-        LOG(ERROR) << "zero radio combinations";
-        return false;
-    }
-    wifi_radio_combination* l_radio_combinations_ptr = legacy_matrix->radio_combinations;
-    for (int i = 0; i < num_combinations; i++) {
-        int num_configurations = l_radio_combinations_ptr->num_radio_configurations;
-        WifiRadioCombination radioCombination;
-        std::vector<WifiRadioConfiguration> radio_configurations_vec;
-        if (!num_configurations) {
-            LOG(ERROR) << "zero radio configurations";
-            return false;
-        }
-        for (int j = 0; j < num_configurations; j++) {
-            WifiRadioConfiguration radioConfiguration;
-            wifi_radio_configuration* l_radio_configurations_ptr =
-                    &l_radio_combinations_ptr->radio_configurations[j];
-            if (!aidl_struct_util::convertLegacyWifiRadioConfigurationToAidl(
-                        l_radio_configurations_ptr, &radioConfiguration)) {
-                LOG(ERROR) << "Error converting wifi radio configuration";
-                return false;
-            }
-            radio_configurations_vec.push_back(radioConfiguration);
-        }
-        radioCombination.radioConfigurations = radio_configurations_vec;
-        radio_combinations_vec.push_back(radioCombination);
-        l_radio_combinations_ptr =
-                (wifi_radio_combination*)((u8*)l_radio_combinations_ptr +
-                                          sizeof(wifi_radio_combination) +
-                                          (sizeof(wifi_radio_configuration) * num_configurations));
-    }
-    aidl_matrix->radioCombinations = radio_combinations_vec;
-    return true;
-}
-
-}  // namespace aidl_struct_util
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/aidl_struct_util.h b/wifi/aidl/default/aidl_struct_util.h
deleted file mode 100644
index 4ebfc10..0000000
--- a/wifi/aidl/default/aidl_struct_util.h
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef AIDL_STRUCT_UTIL_H_
-#define AIDL_STRUCT_UTIL_H_
-
-#include <aidl/android/hardware/wifi/IWifiChip.h>
-#include <aidl/android/hardware/wifi/IWifiChipEventCallback.h>
-#include <aidl/android/hardware/wifi/NanBandIndex.h>
-#include <aidl/android/hardware/wifi/WifiDebugRingBufferFlags.h>
-
-#include <vector>
-
-#include "wifi_legacy_hal.h"
-
-/**
- * This file contains a bunch of functions to convert structs from the legacy
- * HAL to AIDL and vice versa.
- */
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-namespace aidl_struct_util {
-
-// Chip conversion methods.
-bool convertLegacyFeaturesToAidlChipCapabilities(uint64_t legacy_feature_set,
-                                                 uint32_t legacy_logger_feature_set,
-                                                 uint32_t* aidl_caps);
-bool convertLegacyDebugRingBufferStatusToAidl(
-        const legacy_hal::wifi_ring_buffer_status& legacy_status,
-        WifiDebugRingBufferStatus* aidl_status);
-bool convertLegacyVectorOfDebugRingBufferStatusToAidl(
-        const std::vector<legacy_hal::wifi_ring_buffer_status>& legacy_status_vec,
-        std::vector<WifiDebugRingBufferStatus>* aidl_status_vec);
-bool convertLegacyWakeReasonStatsToAidl(const legacy_hal::WakeReasonStats& legacy_stats,
-                                        WifiDebugHostWakeReasonStats* aidl_stats);
-legacy_hal::wifi_power_scenario convertAidlTxPowerScenarioToLegacy(
-        IWifiChip::TxPowerScenario aidl_scenario);
-legacy_hal::wifi_latency_mode convertAidlLatencyModeToLegacy(
-        IWifiChip::LatencyMode aidl_latency_mode);
-bool convertLegacyWifiMacInfosToAidl(
-        const std::vector<legacy_hal::WifiMacInfo>& legacy_mac_infos,
-        std::vector<IWifiChipEventCallback::RadioModeInfo>* aidl_radio_mode_infos);
-legacy_hal::wifi_interface_type convertAidlIfaceTypeToLegacy(IfaceType aidl_interface_type);
-legacy_hal::wifi_multi_sta_use_case convertAidlMultiStaUseCaseToLegacy(
-        IWifiChip::MultiStaUseCase use_case);
-bool convertAidlCoexUnsafeChannelToLegacy(
-        const IWifiChip::CoexUnsafeChannel& aidl_unsafe_channel,
-        legacy_hal::wifi_coex_unsafe_channel* legacy_unsafe_channel);
-bool convertAidlVectorOfCoexUnsafeChannelToLegacy(
-        const std::vector<IWifiChip::CoexUnsafeChannel>& aidl_unsafe_channels,
-        std::vector<legacy_hal::wifi_coex_unsafe_channel>* legacy_unsafe_channels);
-bool convertLegacyRadioCombinationsMatrixToAidl(
-        legacy_hal::wifi_radio_combination_matrix* legacy_matrix,
-        WifiRadioCombinationMatrix* aidl_matrix);
-WifiBand convertLegacyMacBandToAidlWifiBand(uint32_t band);
-WifiAntennaMode convertLegacyAntennaConfigurationToAidl(uint32_t antenna_cfg);
-
-// STA iface conversion methods.
-bool convertLegacyFeaturesToAidlStaCapabilities(uint64_t legacy_feature_set,
-                                                uint32_t legacy_logger_feature_set,
-                                                uint32_t* aidl_caps);
-bool convertLegacyApfCapabilitiesToAidl(const legacy_hal::PacketFilterCapabilities& legacy_caps,
-                                        StaApfPacketFilterCapabilities* aidl_caps);
-bool convertLegacyGscanCapabilitiesToAidl(const legacy_hal::wifi_gscan_capabilities& legacy_caps,
-                                          StaBackgroundScanCapabilities* aidl_caps);
-legacy_hal::wifi_band convertAidlWifiBandToLegacy(WifiBand band);
-bool convertAidlGscanParamsToLegacy(const StaBackgroundScanParameters& aidl_scan_params,
-                                    legacy_hal::wifi_scan_cmd_params* legacy_scan_params);
-// |has_ie_data| indicates whether or not the wifi_scan_result includes 802.11
-// Information Elements (IEs)
-bool convertLegacyGscanResultToAidl(const legacy_hal::wifi_scan_result& legacy_scan_result,
-                                    bool has_ie_data, StaScanResult* aidl_scan_result);
-// |cached_results| is assumed to not include IEs.
-bool convertLegacyVectorOfCachedGscanResultsToAidl(
-        const std::vector<legacy_hal::wifi_cached_scan_results>& legacy_cached_scan_results,
-        std::vector<StaScanData>* aidl_scan_datas);
-bool convertLegacyLinkLayerStatsToAidl(const legacy_hal::LinkLayerStats& legacy_stats,
-                                       StaLinkLayerStats* aidl_stats);
-bool convertLegacyRoamingCapabilitiesToAidl(
-        const legacy_hal::wifi_roaming_capabilities& legacy_caps,
-        StaRoamingCapabilities* aidl_caps);
-bool convertAidlRoamingConfigToLegacy(const StaRoamingConfig& aidl_config,
-                                      legacy_hal::wifi_roaming_config* legacy_config);
-legacy_hal::fw_roaming_state_t convertAidlRoamingStateToLegacy(StaRoamingState state);
-bool convertLegacyVectorOfDebugTxPacketFateToAidl(
-        const std::vector<legacy_hal::wifi_tx_report>& legacy_fates,
-        std::vector<WifiDebugTxPacketFateReport>* aidl_fates);
-bool convertLegacyVectorOfDebugRxPacketFateToAidl(
-        const std::vector<legacy_hal::wifi_rx_report>& legacy_fates,
-        std::vector<WifiDebugRxPacketFateReport>* aidl_fates);
-
-// NAN iface conversion methods.
-void convertToNanStatus(legacy_hal::NanStatusType type, const char* str, size_t max_len,
-                        NanStatus* nanStatus);
-bool convertAidlNanEnableRequestToLegacy(const NanEnableRequest& aidl_request1,
-                                         const NanConfigRequestSupplemental& aidl_request2,
-                                         legacy_hal::NanEnableRequest* legacy_request);
-bool convertAidlNanConfigRequestToLegacy(const NanConfigRequest& aidl_request1,
-                                         const NanConfigRequestSupplemental& aidl_request2,
-                                         legacy_hal::NanConfigRequest* legacy_request);
-bool convertAidlNanPublishRequestToLegacy(const NanPublishRequest& aidl_request,
-                                          legacy_hal::NanPublishRequest* legacy_request);
-bool convertAidlNanSubscribeRequestToLegacy(const NanSubscribeRequest& aidl_request,
-                                            legacy_hal::NanSubscribeRequest* legacy_request);
-bool convertAidlNanTransmitFollowupRequestToLegacy(
-        const NanTransmitFollowupRequest& aidl_request,
-        legacy_hal::NanTransmitFollowupRequest* legacy_request);
-bool convertAidlNanDataPathInitiatorRequestToLegacy(
-        const NanInitiateDataPathRequest& aidl_request,
-        legacy_hal::NanDataPathInitiatorRequest* legacy_request);
-bool convertAidlNanDataPathIndicationResponseToLegacy(
-        const NanRespondToDataPathIndicationRequest& aidl_response,
-        legacy_hal::NanDataPathIndicationResponse* legacy_response);
-bool convertLegacyNanResponseHeaderToAidl(const legacy_hal::NanResponseMsg& legacy_response,
-                                          NanStatus* nanStatus);
-bool convertLegacyNanCapabilitiesResponseToAidl(const legacy_hal::NanCapabilities& legacy_response,
-                                                NanCapabilities* aidl_response);
-bool convertLegacyNanMatchIndToAidl(const legacy_hal::NanMatchInd& legacy_ind,
-                                    NanMatchInd* aidl_ind);
-bool convertLegacyNanFollowupIndToAidl(const legacy_hal::NanFollowupInd& legacy_ind,
-                                       NanFollowupReceivedInd* aidl_ind);
-bool convertLegacyNanDataPathRequestIndToAidl(const legacy_hal::NanDataPathRequestInd& legacy_ind,
-                                              NanDataPathRequestInd* aidl_ind);
-bool convertLegacyNanDataPathConfirmIndToAidl(const legacy_hal::NanDataPathConfirmInd& legacy_ind,
-                                              NanDataPathConfirmInd* aidl_ind);
-bool convertLegacyNanDataPathScheduleUpdateIndToAidl(
-        const legacy_hal::NanDataPathScheduleUpdateInd& legacy_ind,
-        NanDataPathScheduleUpdateInd* aidl_ind);
-
-// RTT controller conversion methods.
-bool convertAidlVectorOfRttConfigToLegacy(const std::vector<RttConfig>& aidl_configs,
-                                          std::vector<legacy_hal::wifi_rtt_config>* legacy_configs);
-bool convertAidlRttLciInformationToLegacy(const RttLciInformation& aidl_info,
-                                          legacy_hal::wifi_lci_information* legacy_info);
-bool convertAidlRttLcrInformationToLegacy(const RttLcrInformation& aidl_info,
-                                          legacy_hal::wifi_lcr_information* legacy_info);
-bool convertAidlRttResponderToLegacy(const RttResponder& aidl_responder,
-                                     legacy_hal::wifi_rtt_responder* legacy_responder);
-bool convertAidlWifiChannelInfoToLegacy(const WifiChannelInfo& aidl_info,
-                                        legacy_hal::wifi_channel_info* legacy_info);
-bool convertLegacyRttResponderToAidl(const legacy_hal::wifi_rtt_responder& legacy_responder,
-                                     RttResponder* aidl_responder);
-bool convertLegacyRttCapabilitiesToAidl(
-        const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
-        RttCapabilities* aidl_capabilities);
-bool convertLegacyVectorOfRttResultToAidl(
-        const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
-        std::vector<RttResult>* aidl_results);
-uint32_t convertAidlWifiBandToLegacyMacBand(WifiBand band);
-uint32_t convertAidlWifiIfaceModeToLegacy(uint32_t aidl_iface_mask);
-uint32_t convertAidlUsableChannelFilterToLegacy(uint32_t aidl_filter_mask);
-bool convertLegacyWifiUsableChannelsToAidl(
-        const std::vector<legacy_hal::wifi_usable_channel>& legacy_usable_channels,
-        std::vector<WifiUsableChannel>* aidl_usable_channels);
-bool convertLegacyPeerInfoStatsToAidl(const legacy_hal::WifiPeerInfo& legacy_peer_info_stats,
-                                      StaPeerInfo* aidl_peer_info_stats);
-bool convertLegacyWifiRateInfoToAidl(const legacy_hal::wifi_rate& legacy_rate,
-                                     WifiRateInfo* aidl_rate);
-}  // namespace aidl_struct_util
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
-
-#endif  // AIDL_STRUCT_UTIL_H_
diff --git a/wifi/aidl/default/android.hardware.wifi-service-lazy.rc b/wifi/aidl/default/android.hardware.wifi-service-lazy.rc
deleted file mode 100644
index 12d3ff7..0000000
--- a/wifi/aidl/default/android.hardware.wifi-service-lazy.rc
+++ /dev/null
@@ -1,8 +0,0 @@
-service vendor.wifi_hal_legacy /vendor/bin/hw/android.hardware.wifi-service-lazy
-    interface aidl android.hardware.wifi.IWifi/default
-    oneshot
-    disabled
-    class hal
-    capabilities NET_ADMIN NET_RAW SYS_MODULE
-    user wifi
-    group wifi gps
diff --git a/wifi/aidl/default/android.hardware.wifi-service.rc b/wifi/aidl/default/android.hardware.wifi-service.rc
deleted file mode 100644
index ec8acf5..0000000
--- a/wifi/aidl/default/android.hardware.wifi-service.rc
+++ /dev/null
@@ -1,6 +0,0 @@
-service vendor.wifi_hal_legacy /vendor/bin/hw/android.hardware.wifi-service
-    interface aidl android.hardware.wifi.IWifi/default
-    class hal
-    capabilities NET_ADMIN NET_RAW SYS_MODULE
-    user wifi
-    group wifi gps
diff --git a/wifi/aidl/default/android.hardware.wifi-service.xml b/wifi/aidl/default/android.hardware.wifi-service.xml
deleted file mode 100644
index 5398ee7..0000000
--- a/wifi/aidl/default/android.hardware.wifi-service.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<manifest version="1.0" type="device">
-	<hal format="aidl">
-		<name>android.hardware.wifi</name>
-		<fqname>IWifi/default</fqname>
-	</hal>
-</manifest>
diff --git a/wifi/aidl/default/service.cpp b/wifi/aidl/default/service.cpp
deleted file mode 100644
index 789a7a5..0000000
--- a/wifi/aidl/default/service.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <android-base/logging.h>
-#include <android/binder_manager.h>
-#include <android/binder_process.h>
-#include <signal.h>
-
-#include "wifi.h"
-#include "wifi_feature_flags.h"
-#include "wifi_legacy_hal.h"
-#include "wifi_legacy_hal_factory.h"
-#include "wifi_mode_controller.h"
-
-using aidl::android::hardware::wifi::feature_flags::WifiFeatureFlags;
-using aidl::android::hardware::wifi::legacy_hal::WifiLegacyHal;
-using aidl::android::hardware::wifi::legacy_hal::WifiLegacyHalFactory;
-using aidl::android::hardware::wifi::mode_controller::WifiModeController;
-
-#ifdef LAZY_SERVICE
-const bool kLazyService = true;
-#else
-const bool kLazyService = false;
-#endif
-
-int main(int /*argc*/, char** argv) {
-    signal(SIGPIPE, SIG_IGN);
-    android::base::InitLogging(argv, android::base::LogdLogger(android::base::SYSTEM));
-    LOG(INFO) << "Wifi Hal is booting up...";
-
-    // Prepare the RPC-serving thread pool. Allocate 1 thread in the pool,
-    // which our main thread will join below.
-    ABinderProcess_setThreadPoolMaxThreadCount(1);
-
-    const auto iface_tool = std::make_shared<::android::wifi_system::InterfaceTool>();
-    const auto legacy_hal_factory = std::make_shared<WifiLegacyHalFactory>(iface_tool);
-
-    // Setup binder service
-    std::shared_ptr<aidl::android::hardware::wifi::Wifi> service =
-            ndk::SharedRefBase::make<aidl::android::hardware::wifi::Wifi>(
-                    iface_tool, legacy_hal_factory, std::make_shared<WifiModeController>(),
-                    std::make_shared<WifiFeatureFlags>());
-    std::string instance =
-            std::string() + aidl::android::hardware::wifi::Wifi::descriptor + "/default";
-    if (kLazyService) {
-        auto result =
-                AServiceManager_registerLazyService(service->asBinder().get(), instance.c_str());
-        CHECK_EQ(result, STATUS_OK) << "Failed to register lazy wifi HAL";
-    } else {
-        auto result = AServiceManager_addService(service->asBinder().get(), instance.c_str());
-        CHECK_EQ(result, STATUS_OK) << "Failed to register wifi HAL";
-    }
-
-    ABinderProcess_startThreadPool();
-    LOG(INFO) << "Joining RPC thread pool";
-    ABinderProcess_joinThreadPool();
-
-    LOG(INFO) << "Wifi Hal is terminating...";
-    return 0;
-}
diff --git a/wifi/aidl/default/tests/wifi_nan_iface_unit_tests.cpp b/wifi/aidl/default/tests/wifi_nan_iface_unit_tests.cpp
deleted file mode 100644
index d40801f..0000000
--- a/wifi/aidl/default/tests/wifi_nan_iface_unit_tests.cpp
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <android-base/logging.h>
-#include <android-base/macros.h>
-#include <cutils/properties.h>
-#include <gmock/gmock.h>
-
-#include "wifi_nan_iface.h"
-
-#include "mock_interface_tool.h"
-#include "mock_wifi_feature_flags.h"
-#include "mock_wifi_iface_util.h"
-#include "mock_wifi_legacy_hal.h"
-
-using testing::NiceMock;
-using testing::Return;
-using testing::Test;
-
-namespace {
-constexpr char kIfaceName[] = "mockWlan0";
-}  // namespace
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-
-bool CaptureIfaceEventHandlers(const std::string& /* iface_name*/,
-                               iface_util::IfaceEventHandlers in_iface_event_handlers,
-                               iface_util::IfaceEventHandlers* out_iface_event_handlers) {
-    *out_iface_event_handlers = in_iface_event_handlers;
-    return true;
-}
-
-class MockNanIface : public WifiNanIface {
-  public:
-    MockNanIface(const std::string& ifname, bool is_dedicated_iface,
-                 const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-                 const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
-        : WifiNanIface(ifname, is_dedicated_iface, legacy_hal, iface_util) {}
-
-    static std::shared_ptr<MockNanIface> createMock(
-            const std::string& ifname, bool is_dedicated_iface,
-            const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-            const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util) {
-        std::shared_ptr<MockNanIface> ptr = ndk::SharedRefBase::make<MockNanIface>(
-                ifname, is_dedicated_iface, legacy_hal, iface_util);
-        std::weak_ptr<MockNanIface> weak_ptr_this(ptr);
-        ptr->setWeakPtr(weak_ptr_this);
-        ptr->registerCallbackHandlers();
-        return ptr;
-    }
-
-    // Override getEventCallbacks() so that we can return a mocked callback object.
-    std::set<std::shared_ptr<IWifiNanIfaceEventCallback>> getEventCallbacks() override {
-        return {callback_};
-    }
-
-    void setMockCallback(std::shared_ptr<IWifiNanIfaceEventCallback> cb) { callback_ = cb; }
-
-  private:
-    std::shared_ptr<IWifiNanIfaceEventCallback> callback_;
-};
-
-class MockNanIfaceEventCallback : public IWifiNanIfaceEventCallback {
-  public:
-    ndk::SpAIBinder asBinder() override { return ::ndk::SpAIBinder{}; }
-    bool isRemote() override { return false; }
-
-    ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override {
-        *_aidl_return = 1;
-        return ndk::ScopedAStatus::ok();
-    }
-    ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override {
-        *_aidl_return = "some_hash";
-        return ndk::ScopedAStatus::ok();
-    }
-
-    MOCK_METHOD3(notifyCapabilitiesResponse,
-                 ndk::ScopedAStatus(char16_t, const NanStatus&, const NanCapabilities&));
-    MOCK_METHOD2(notifyEnableResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
-    MOCK_METHOD2(notifyConfigResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
-    MOCK_METHOD2(notifyDisableResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
-    MOCK_METHOD3(notifyStartPublishResponse,
-                 ndk::ScopedAStatus(char16_t, const NanStatus&, int8_t));
-    MOCK_METHOD2(notifyStopPublishResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
-    MOCK_METHOD3(notifyStartSubscribeResponse,
-                 ndk::ScopedAStatus(char16_t, const NanStatus&, int8_t));
-    MOCK_METHOD2(notifyStopSubscribeResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
-    MOCK_METHOD2(notifyTransmitFollowupResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
-    MOCK_METHOD2(notifyCreateDataInterfaceResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
-    MOCK_METHOD2(notifyDeleteDataInterfaceResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
-    MOCK_METHOD3(notifyInitiateDataPathResponse,
-                 ndk::ScopedAStatus(char16_t, const NanStatus&, int32_t));
-    MOCK_METHOD2(notifyRespondToDataPathIndicationResponse,
-                 ndk::ScopedAStatus(char16_t, const NanStatus&));
-    MOCK_METHOD2(notifyTerminateDataPathResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
-    MOCK_METHOD1(eventClusterEvent, ndk::ScopedAStatus(const NanClusterEventInd&));
-    MOCK_METHOD1(eventDisabled, ndk::ScopedAStatus(const NanStatus&));
-    MOCK_METHOD2(eventPublishTerminated, ndk::ScopedAStatus(int8_t, const NanStatus&));
-    MOCK_METHOD2(eventSubscribeTerminated, ndk::ScopedAStatus(int8_t, const NanStatus&));
-    MOCK_METHOD1(eventMatch, ndk::ScopedAStatus(const NanMatchInd&));
-    MOCK_METHOD2(eventMatchExpired, ndk::ScopedAStatus(int8_t, int32_t));
-    MOCK_METHOD1(eventFollowupReceived, ndk::ScopedAStatus(const NanFollowupReceivedInd&));
-    MOCK_METHOD2(eventTransmitFollowup, ndk::ScopedAStatus(char16_t, const NanStatus&));
-    MOCK_METHOD1(eventDataPathRequest, ndk::ScopedAStatus(const NanDataPathRequestInd&));
-    MOCK_METHOD1(eventDataPathConfirm, ndk::ScopedAStatus(const NanDataPathConfirmInd&));
-    MOCK_METHOD1(eventDataPathTerminated, ndk::ScopedAStatus(int32_t));
-    MOCK_METHOD1(eventDataPathScheduleUpdate,
-                 ndk::ScopedAStatus(const NanDataPathScheduleUpdateInd&));
-};
-
-class WifiNanIfaceTest : public Test {
-  protected:
-    legacy_hal::wifi_hal_fn fake_func_table_;
-    std::shared_ptr<NiceMock<::android::wifi_system::MockInterfaceTool>> iface_tool_{
-            new NiceMock<::android::wifi_system::MockInterfaceTool>};
-    std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
-            new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_, fake_func_table_, true)};
-    std::shared_ptr<NiceMock<iface_util::MockWifiIfaceUtil>> iface_util_{
-            new NiceMock<iface_util::MockWifiIfaceUtil>(iface_tool_, legacy_hal_)};
-};
-
-TEST_F(WifiNanIfaceTest, IfacEventHandlers_OnStateToggleOffOn) {
-    // Ensure that event handlers are registered during nan iface creation.
-    iface_util::IfaceEventHandlers captured_iface_event_handlers = {};
-    EXPECT_CALL(*legacy_hal_, nanRegisterCallbackHandlers(testing::_, testing::_))
-            .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
-    EXPECT_CALL(*iface_util_, registerIfaceEventHandlers(testing::_, testing::_))
-            .WillOnce(testing::Invoke(bind(CaptureIfaceEventHandlers, std::placeholders::_1,
-                                           std::placeholders::_2, &captured_iface_event_handlers)));
-
-    // Create nan iface and register a callback.
-    // Note: Since we can't register a callback directly (gTest fails on
-    //       AIBinder_linkToDeath), simulate the registration by overriding
-    //       getEventCallbacks() to return our mock callback object.
-    std::shared_ptr<MockNanIface> mock_nan_iface =
-            MockNanIface::createMock(kIfaceName, false, legacy_hal_, iface_util_);
-    std::shared_ptr<MockNanIfaceEventCallback> mock_event_callback =
-            ndk::SharedRefBase::make<MockNanIfaceEventCallback>();
-    mock_nan_iface->setMockCallback(mock_event_callback);
-
-    // Ensure that the eventDisabled() function in the mock callback will be invoked.
-    NanStatus expected_nan_status = {NanStatusCode::UNSUPPORTED_CONCURRENCY_NAN_DISABLED, ""};
-    EXPECT_CALL(*mock_event_callback, eventDisabled(expected_nan_status)).Times(1);
-
-    // Trigger the iface state toggle callback.
-    captured_iface_event_handlers.on_state_toggle_off_on(kIfaceName);
-}
-
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/wifi.h b/wifi/aidl/default/wifi.h
deleted file mode 100644
index 9334524..0000000
--- a/wifi/aidl/default/wifi.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef WIFI_H_
-#define WIFI_H_
-
-#include <aidl/android/hardware/wifi/BnWifi.h>
-#include <android-base/macros.h>
-#include <utils/Looper.h>
-
-#include <functional>
-
-#include "aidl_callback_util.h"
-#include "wifi_chip.h"
-#include "wifi_feature_flags.h"
-#include "wifi_legacy_hal.h"
-#include "wifi_legacy_hal_factory.h"
-#include "wifi_mode_controller.h"
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-
-/**
- * Root AIDL interface object used to control the Wifi HAL.
- */
-class Wifi : public BnWifi {
-  public:
-    Wifi(const std::shared_ptr<::android::wifi_system::InterfaceTool> iface_tool,
-         const std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory,
-         const std::shared_ptr<mode_controller::WifiModeController> mode_controller,
-         const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags);
-
-    bool isValid();
-
-    // AIDL methods exposed.
-    ndk::ScopedAStatus registerEventCallback(
-            const std::shared_ptr<IWifiEventCallback>& in_callback) override;
-    ndk::ScopedAStatus isStarted(bool* _aidl_return) override;
-    ndk::ScopedAStatus start() override;
-    ndk::ScopedAStatus stop() override;
-    ndk::ScopedAStatus getChipIds(std::vector<int32_t>* _aidl_return) override;
-    ndk::ScopedAStatus getChip(int32_t in_chipId,
-                               std::shared_ptr<IWifiChip>* _aidl_return) override;
-    binder_status_t dump(int fd, const char** args, uint32_t numArgs) override;
-
-  private:
-    enum class RunState { STOPPED, STARTED, STOPPING };
-
-    // Corresponding worker functions for the AIDL methods.
-    ndk::ScopedAStatus registerEventCallbackInternal(
-            const std::shared_ptr<IWifiEventCallback>& event_callback __unused);
-    ndk::ScopedAStatus startInternal();
-    ndk::ScopedAStatus stopInternal(std::unique_lock<std::recursive_mutex>* lock);
-    std::pair<std::vector<int32_t>, ndk::ScopedAStatus> getChipIdsInternal();
-    std::pair<std::shared_ptr<IWifiChip>, ndk::ScopedAStatus> getChipInternal(int32_t chip_id);
-
-    ndk::ScopedAStatus initializeModeControllerAndLegacyHal();
-    ndk::ScopedAStatus stopLegacyHalAndDeinitializeModeController(
-            std::unique_lock<std::recursive_mutex>* lock);
-    int32_t getChipIdFromWifiChip(std::shared_ptr<WifiChip>& chip);
-
-    // Instance is created in this root level |IWifi| AIDL interface object
-    // and shared with all the child AIDL interface objects.
-    std::shared_ptr<::android::wifi_system::InterfaceTool> iface_tool_;
-    std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory_;
-    std::shared_ptr<mode_controller::WifiModeController> mode_controller_;
-    std::vector<std::shared_ptr<legacy_hal::WifiLegacyHal>> legacy_hals_;
-    std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags_;
-    RunState run_state_;
-    std::vector<std::shared_ptr<WifiChip>> chips_;
-    aidl_callback_util::AidlCallbackHandler<IWifiEventCallback> event_cb_handler_;
-
-    DISALLOW_COPY_AND_ASSIGN(Wifi);
-};
-
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
-
-#endif  // WIFI_H_
diff --git a/wifi/aidl/default/wifi_ap_iface.cpp b/wifi/aidl/default/wifi_ap_iface.cpp
deleted file mode 100644
index 6cd932d..0000000
--- a/wifi/aidl/default/wifi_ap_iface.cpp
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "wifi_ap_iface.h"
-
-#include <android-base/logging.h>
-
-#include "aidl_return_util.h"
-#include "aidl_struct_util.h"
-#include "wifi_status_util.h"
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-using aidl_return_util::validateAndCall;
-
-WifiApIface::WifiApIface(const std::string& ifname, const std::vector<std::string>& instances,
-                         const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-                         const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
-    : ifname_(ifname),
-      instances_(instances),
-      legacy_hal_(legacy_hal),
-      iface_util_(iface_util),
-      is_valid_(true) {}
-
-void WifiApIface::invalidate() {
-    legacy_hal_.reset();
-    is_valid_ = false;
-}
-
-bool WifiApIface::isValid() {
-    return is_valid_;
-}
-
-std::string WifiApIface::getName() {
-    return ifname_;
-}
-
-void WifiApIface::removeInstance(std::string instance) {
-    instances_.erase(std::remove(instances_.begin(), instances_.end(), instance), instances_.end());
-}
-
-ndk::ScopedAStatus WifiApIface::getName(std::string* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiApIface::getNameInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiApIface::setCountryCode(const std::array<uint8_t, 2>& in_code) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiApIface::setCountryCodeInternal, in_code);
-}
-
-ndk::ScopedAStatus WifiApIface::getValidFrequenciesForBand(WifiBand in_band,
-                                                           std::vector<int32_t>* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiApIface::getValidFrequenciesForBandInternal, _aidl_return, in_band);
-}
-
-ndk::ScopedAStatus WifiApIface::setMacAddress(const std::array<uint8_t, 6>& in_mac) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiApIface::setMacAddressInternal, in_mac);
-}
-
-ndk::ScopedAStatus WifiApIface::getFactoryMacAddress(std::array<uint8_t, 6>* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiApIface::getFactoryMacAddressInternal, _aidl_return,
-                           instances_.size() > 0 ? instances_[0] : ifname_);
-}
-
-ndk::ScopedAStatus WifiApIface::resetToFactoryMacAddress() {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiApIface::resetToFactoryMacAddressInternal);
-}
-
-ndk::ScopedAStatus WifiApIface::getBridgedInstances(std::vector<std::string>* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiApIface::getBridgedInstancesInternal, _aidl_return);
-}
-
-std::pair<std::string, ndk::ScopedAStatus> WifiApIface::getNameInternal() {
-    return {ifname_, ndk::ScopedAStatus::ok()};
-}
-
-ndk::ScopedAStatus WifiApIface::setCountryCodeInternal(const std::array<uint8_t, 2>& code) {
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setCountryCode(
-            instances_.size() > 0 ? instances_[0] : ifname_, code);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-std::pair<std::vector<int32_t>, ndk::ScopedAStatus> WifiApIface::getValidFrequenciesForBandInternal(
-        WifiBand band) {
-    static_assert(sizeof(WifiChannelWidthInMhz) == sizeof(int32_t), "Size mismatch");
-    legacy_hal::wifi_error legacy_status;
-    std::vector<uint32_t> valid_frequencies;
-    std::tie(legacy_status, valid_frequencies) = legacy_hal_.lock()->getValidFrequenciesForBand(
-            instances_.size() > 0 ? instances_[0] : ifname_,
-            aidl_struct_util::convertAidlWifiBandToLegacy(band));
-    return {std::vector<int32_t>(valid_frequencies.begin(), valid_frequencies.end()),
-            createWifiStatusFromLegacyError(legacy_status)};
-}
-
-ndk::ScopedAStatus WifiApIface::setMacAddressInternal(const std::array<uint8_t, 6>& mac) {
-    // Support random MAC up to 2 interfaces
-    if (instances_.size() == 2) {
-        int rbyte = 1;
-        for (auto const& intf : instances_) {
-            std::array<uint8_t, 6> rmac = mac;
-            // reverse the bits to avoid collision
-            rmac[rbyte] = 0xff - rmac[rbyte];
-            if (!iface_util_.lock()->setMacAddress(intf, rmac)) {
-                LOG(INFO) << "Failed to set random mac address on " << intf;
-                return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
-            }
-            rbyte++;
-        }
-    }
-    // It also needs to set mac address for bridged interface, otherwise the mac
-    // address of bridged interface will be changed after one of instance
-    // down.
-    if (!iface_util_.lock()->setMacAddress(ifname_, mac)) {
-        LOG(ERROR) << "Fail to config MAC for interface " << ifname_;
-        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
-    }
-    return ndk::ScopedAStatus::ok();
-}
-
-std::pair<std::array<uint8_t, 6>, ndk::ScopedAStatus> WifiApIface::getFactoryMacAddressInternal(
-        const std::string& ifaceName) {
-    std::array<uint8_t, 6> mac = iface_util_.lock()->getFactoryMacAddress(ifaceName);
-    if (mac[0] == 0 && mac[1] == 0 && mac[2] == 0 && mac[3] == 0 && mac[4] == 0 && mac[5] == 0) {
-        return {mac, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
-    }
-    return {mac, ndk::ScopedAStatus::ok()};
-}
-
-ndk::ScopedAStatus WifiApIface::resetToFactoryMacAddressInternal() {
-    std::pair<std::array<uint8_t, 6>, ndk::ScopedAStatus> getMacResult;
-    if (instances_.size() == 2) {
-        for (auto const& intf : instances_) {
-            getMacResult = getFactoryMacAddressInternal(intf);
-            LOG(DEBUG) << "Reset MAC to factory MAC on " << intf;
-            if (!getMacResult.second.isOk() ||
-                !iface_util_.lock()->setMacAddress(intf, getMacResult.first)) {
-                return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
-            }
-        }
-        // We need to set mac address for bridged interface, otherwise the mac
-        // address of the bridged interface will be changed after one of the
-        // instances goes down. Thus we are generating a random MAC address for
-        // the bridged interface even if we got the request to reset the Factory
-        // MAC. This is because the bridged interface is an internal interface
-        // for the operation of bpf and other networking operations.
-        if (!iface_util_.lock()->setMacAddress(ifname_,
-                                               iface_util_.lock()->createRandomMacAddress())) {
-            LOG(ERROR) << "Fail to config MAC for bridged interface " << ifname_;
-            return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
-        }
-    } else {
-        getMacResult = getFactoryMacAddressInternal(ifname_);
-        LOG(DEBUG) << "Reset MAC to factory MAC on " << ifname_;
-        if (!getMacResult.second.isOk() ||
-            !iface_util_.lock()->setMacAddress(ifname_, getMacResult.first)) {
-            return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
-        }
-    }
-    return ndk::ScopedAStatus::ok();
-}
-
-std::pair<std::vector<std::string>, ndk::ScopedAStatus> WifiApIface::getBridgedInstancesInternal() {
-    return {instances_, ndk::ScopedAStatus::ok()};
-}
-
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/wifi_ap_iface.h b/wifi/aidl/default/wifi_ap_iface.h
deleted file mode 100644
index b5673fc..0000000
--- a/wifi/aidl/default/wifi_ap_iface.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef WIFI_AP_IFACE_H_
-#define WIFI_AP_IFACE_H_
-
-#include <aidl/android/hardware/wifi/BnWifiApIface.h>
-#include <android-base/macros.h>
-
-#include "wifi_iface_util.h"
-#include "wifi_legacy_hal.h"
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-
-/**
- * AIDL interface object used to control an AP Iface instance.
- */
-class WifiApIface : public BnWifiApIface {
-  public:
-    WifiApIface(const std::string& ifname, const std::vector<std::string>& instances,
-                const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-                const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
-    // Refer to |WifiChip::invalidate()|.
-    void invalidate();
-    bool isValid();
-    std::string getName();
-    void removeInstance(std::string instance);
-
-    // AIDL methods exposed.
-    ndk::ScopedAStatus getName(std::string* _aidl_return) override;
-    ndk::ScopedAStatus setCountryCode(const std::array<uint8_t, 2>& in_code) override;
-    ndk::ScopedAStatus getValidFrequenciesForBand(WifiBand in_band,
-                                                  std::vector<int32_t>* _aidl_return) override;
-    ndk::ScopedAStatus setMacAddress(const std::array<uint8_t, 6>& in_mac) override;
-    ndk::ScopedAStatus getFactoryMacAddress(std::array<uint8_t, 6>* _aidl_return) override;
-    ndk::ScopedAStatus resetToFactoryMacAddress() override;
-    ndk::ScopedAStatus getBridgedInstances(std::vector<std::string>* _aidl_return) override;
-
-  private:
-    // Corresponding worker functions for the AIDL methods.
-    std::pair<std::string, ndk::ScopedAStatus> getNameInternal();
-    ndk::ScopedAStatus setCountryCodeInternal(const std::array<uint8_t, 2>& code);
-    std::pair<std::vector<int32_t>, ndk::ScopedAStatus> getValidFrequenciesForBandInternal(
-            WifiBand band);
-    ndk::ScopedAStatus setMacAddressInternal(const std::array<uint8_t, 6>& mac);
-    std::pair<std::array<uint8_t, 6>, ndk::ScopedAStatus> getFactoryMacAddressInternal(
-            const std::string& ifaceName);
-    ndk::ScopedAStatus resetToFactoryMacAddressInternal();
-    std::pair<std::vector<std::string>, ndk::ScopedAStatus> getBridgedInstancesInternal();
-
-    std::string ifname_;
-    std::vector<std::string> instances_;
-    std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
-    std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
-    bool is_valid_;
-
-    DISALLOW_COPY_AND_ASSIGN(WifiApIface);
-};
-
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
-
-#endif  // WIFI_AP_IFACE_H_
diff --git a/wifi/aidl/default/wifi_chip.h b/wifi/aidl/default/wifi_chip.h
deleted file mode 100644
index 59eaa4a..0000000
--- a/wifi/aidl/default/wifi_chip.h
+++ /dev/null
@@ -1,287 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef WIFI_CHIP_H_
-#define WIFI_CHIP_H_
-
-#include <aidl/android/hardware/wifi/BnWifiChip.h>
-#include <aidl/android/hardware/wifi/IWifiRttController.h>
-#include <android-base/macros.h>
-
-#include <list>
-#include <map>
-#include <mutex>
-
-#include "aidl_callback_util.h"
-#include "ringbuffer.h"
-#include "wifi_ap_iface.h"
-#include "wifi_feature_flags.h"
-#include "wifi_legacy_hal.h"
-#include "wifi_mode_controller.h"
-#include "wifi_nan_iface.h"
-#include "wifi_p2p_iface.h"
-#include "wifi_rtt_controller.h"
-#include "wifi_sta_iface.h"
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-
-/**
- * AIDL interface object used to control a Wifi HAL chip instance.
- * Since there is only a single chip instance used today, there is no
- * identifying handle information stored here.
- */
-class WifiChip : public BnWifiChip {
-  public:
-    WifiChip(int32_t chip_id, bool is_primary,
-             const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-             const std::weak_ptr<mode_controller::WifiModeController> mode_controller,
-             const std::shared_ptr<iface_util::WifiIfaceUtil> iface_util,
-             const std::weak_ptr<feature_flags::WifiFeatureFlags> feature_flags,
-             const std::function<void(const std::string&)>& subsystemCallbackHandler);
-
-    // Factory method - use instead of default constructor.
-    static std::shared_ptr<WifiChip> create(
-            int32_t chip_id, bool is_primary,
-            const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-            const std::weak_ptr<mode_controller::WifiModeController> mode_controller,
-            const std::shared_ptr<iface_util::WifiIfaceUtil> iface_util,
-            const std::weak_ptr<feature_flags::WifiFeatureFlags> feature_flags,
-            const std::function<void(const std::string&)>& subsystemCallbackHandler);
-
-    // AIDL does not provide a built-in mechanism to let the server invalidate
-    // an AIDL interface object after creation. If any client process holds onto
-    // a reference to the object in their context, any method calls on that
-    // reference will continue to be directed to the server.
-    //
-    // However Wifi HAL needs to control the lifetime of these objects. So, add
-    // a public |invalidate| method to |WifiChip| and its child objects. This
-    // will be used to mark an object invalid when either:
-    // a) Wifi HAL is stopped, or
-    // b) Wifi Chip is reconfigured.
-    //
-    // All AIDL method implementations should check if the object is still
-    // marked valid before processing them.
-    void invalidate();
-    bool isValid();
-    std::set<std::shared_ptr<IWifiChipEventCallback>> getEventCallbacks();
-
-    // AIDL methods exposed.
-    ndk::ScopedAStatus getId(int32_t* _aidl_return) override;
-    ndk::ScopedAStatus registerEventCallback(
-            const std::shared_ptr<IWifiChipEventCallback>& in_callback) override;
-    ndk::ScopedAStatus getCapabilities(IWifiChip::ChipCapabilityMask* _aidl_return) override;
-    ndk::ScopedAStatus getAvailableModes(std::vector<IWifiChip::ChipMode>* _aidl_return) override;
-    ndk::ScopedAStatus configureChip(int32_t in_modeId) override;
-    ndk::ScopedAStatus getMode(int32_t* _aidl_return) override;
-    ndk::ScopedAStatus requestChipDebugInfo(IWifiChip::ChipDebugInfo* _aidl_return) override;
-    ndk::ScopedAStatus requestDriverDebugDump(std::vector<uint8_t>* _aidl_return) override;
-    ndk::ScopedAStatus requestFirmwareDebugDump(std::vector<uint8_t>* _aidl_return) override;
-    ndk::ScopedAStatus createApIface(std::shared_ptr<IWifiApIface>* _aidl_return) override;
-    ndk::ScopedAStatus createBridgedApIface(std::shared_ptr<IWifiApIface>* _aidl_return) override;
-    ndk::ScopedAStatus getApIfaceNames(std::vector<std::string>* _aidl_return) override;
-    ndk::ScopedAStatus getApIface(const std::string& in_ifname,
-                                  std::shared_ptr<IWifiApIface>* _aidl_return) override;
-    ndk::ScopedAStatus removeApIface(const std::string& in_ifname) override;
-    ndk::ScopedAStatus removeIfaceInstanceFromBridgedApIface(
-            const std::string& in_brIfaceName, const std::string& in_ifaceInstanceName) override;
-    ndk::ScopedAStatus createNanIface(std::shared_ptr<IWifiNanIface>* _aidl_return) override;
-    ndk::ScopedAStatus getNanIfaceNames(std::vector<std::string>* _aidl_return) override;
-    ndk::ScopedAStatus getNanIface(const std::string& in_ifname,
-                                   std::shared_ptr<IWifiNanIface>* _aidl_return) override;
-    ndk::ScopedAStatus removeNanIface(const std::string& in_ifname) override;
-    ndk::ScopedAStatus createP2pIface(std::shared_ptr<IWifiP2pIface>* _aidl_return) override;
-    ndk::ScopedAStatus getP2pIfaceNames(std::vector<std::string>* _aidl_return) override;
-    ndk::ScopedAStatus getP2pIface(const std::string& in_ifname,
-                                   std::shared_ptr<IWifiP2pIface>* _aidl_return) override;
-    ndk::ScopedAStatus removeP2pIface(const std::string& in_ifname) override;
-    ndk::ScopedAStatus createStaIface(std::shared_ptr<IWifiStaIface>* _aidl_return) override;
-    ndk::ScopedAStatus getStaIfaceNames(std::vector<std::string>* _aidl_return) override;
-    ndk::ScopedAStatus getStaIface(const std::string& in_ifname,
-                                   std::shared_ptr<IWifiStaIface>* _aidl_return) override;
-    ndk::ScopedAStatus removeStaIface(const std::string& in_ifname) override;
-    ndk::ScopedAStatus createRttController(
-            const std::shared_ptr<IWifiStaIface>& in_boundIface,
-            std::shared_ptr<IWifiRttController>* _aidl_return) override;
-    ndk::ScopedAStatus getDebugRingBuffersStatus(
-            std::vector<WifiDebugRingBufferStatus>* _aidl_return) override;
-    ndk::ScopedAStatus startLoggingToDebugRingBuffer(
-            const std::string& in_ringName, WifiDebugRingBufferVerboseLevel in_verboseLevel,
-            int32_t in_maxIntervalInSec, int32_t in_minDataSizeInBytes) override;
-    ndk::ScopedAStatus forceDumpToDebugRingBuffer(const std::string& in_ringName) override;
-    ndk::ScopedAStatus flushRingBufferToFile() override;
-    ndk::ScopedAStatus stopLoggingToDebugRingBuffer() override;
-    ndk::ScopedAStatus getDebugHostWakeReasonStats(
-            WifiDebugHostWakeReasonStats* _aidl_return) override;
-    ndk::ScopedAStatus enableDebugErrorAlerts(bool in_enable) override;
-    ndk::ScopedAStatus selectTxPowerScenario(IWifiChip::TxPowerScenario in_scenario) override;
-    ndk::ScopedAStatus resetTxPowerScenario() override;
-    ndk::ScopedAStatus setLatencyMode(IWifiChip::LatencyMode in_mode) override;
-    ndk::ScopedAStatus setMultiStaPrimaryConnection(const std::string& in_ifName) override;
-    ndk::ScopedAStatus setMultiStaUseCase(IWifiChip::MultiStaUseCase in_useCase) override;
-    ndk::ScopedAStatus setCoexUnsafeChannels(
-            const std::vector<IWifiChip::CoexUnsafeChannel>& in_unsafeChannels,
-            CoexRestriction in_restrictions) override;
-    ndk::ScopedAStatus setCountryCode(const std::array<uint8_t, 2>& in_code) override;
-    ndk::ScopedAStatus getUsableChannels(WifiBand in_band, WifiIfaceMode in_ifaceModeMask,
-                                         UsableChannelFilter in_filterMask,
-                                         std::vector<WifiUsableChannel>* _aidl_return) override;
-    ndk::ScopedAStatus triggerSubsystemRestart() override;
-    ndk::ScopedAStatus getSupportedRadioCombinationsMatrix(
-            WifiRadioCombinationMatrix* _aidl_return) override;
-    binder_status_t dump(int fd, const char** args, uint32_t numArgs) override;
-
-  private:
-    void invalidateAndRemoveAllIfaces();
-    // When a STA iface is removed any dependent NAN-ifaces/RTT-controllers are
-    // invalidated & removed.
-    void invalidateAndRemoveDependencies(const std::string& removed_iface_name);
-
-    // Corresponding worker functions for the AIDL methods.
-    std::pair<int32_t, ndk::ScopedAStatus> getIdInternal();
-    ndk::ScopedAStatus registerEventCallbackInternal(
-            const std::shared_ptr<IWifiChipEventCallback>& event_callback);
-    std::pair<IWifiChip::ChipCapabilityMask, ndk::ScopedAStatus> getCapabilitiesInternal();
-    std::pair<std::vector<IWifiChip::ChipMode>, ndk::ScopedAStatus> getAvailableModesInternal();
-    ndk::ScopedAStatus configureChipInternal(std::unique_lock<std::recursive_mutex>* lock,
-                                             int32_t mode_id);
-    std::pair<int32_t, ndk::ScopedAStatus> getModeInternal();
-    std::pair<IWifiChip::ChipDebugInfo, ndk::ScopedAStatus> requestChipDebugInfoInternal();
-    std::pair<std::vector<uint8_t>, ndk::ScopedAStatus> requestDriverDebugDumpInternal();
-    std::pair<std::vector<uint8_t>, ndk::ScopedAStatus> requestFirmwareDebugDumpInternal();
-    std::shared_ptr<WifiApIface> newWifiApIface(std::string& ifname);
-    ndk::ScopedAStatus createVirtualApInterface(const std::string& apVirtIf);
-    std::pair<std::shared_ptr<IWifiApIface>, ndk::ScopedAStatus> createApIfaceInternal();
-    std::pair<std::shared_ptr<IWifiApIface>, ndk::ScopedAStatus> createBridgedApIfaceInternal();
-    std::pair<std::vector<std::string>, ndk::ScopedAStatus> getApIfaceNamesInternal();
-    std::pair<std::shared_ptr<IWifiApIface>, ndk::ScopedAStatus> getApIfaceInternal(
-            const std::string& ifname);
-    ndk::ScopedAStatus removeApIfaceInternal(const std::string& ifname);
-    ndk::ScopedAStatus removeIfaceInstanceFromBridgedApIfaceInternal(
-            const std::string& brIfaceName, const std::string& ifInstanceName);
-    std::pair<std::shared_ptr<IWifiNanIface>, ndk::ScopedAStatus> createNanIfaceInternal();
-    std::pair<std::vector<std::string>, ndk::ScopedAStatus> getNanIfaceNamesInternal();
-    std::pair<std::shared_ptr<IWifiNanIface>, ndk::ScopedAStatus> getNanIfaceInternal(
-            const std::string& ifname);
-    ndk::ScopedAStatus removeNanIfaceInternal(const std::string& ifname);
-    std::pair<std::shared_ptr<IWifiP2pIface>, ndk::ScopedAStatus> createP2pIfaceInternal();
-    std::pair<std::vector<std::string>, ndk::ScopedAStatus> getP2pIfaceNamesInternal();
-    std::pair<std::shared_ptr<IWifiP2pIface>, ndk::ScopedAStatus> getP2pIfaceInternal(
-            const std::string& ifname);
-    ndk::ScopedAStatus removeP2pIfaceInternal(const std::string& ifname);
-    std::pair<std::shared_ptr<IWifiStaIface>, ndk::ScopedAStatus> createStaIfaceInternal();
-    std::pair<std::vector<std::string>, ndk::ScopedAStatus> getStaIfaceNamesInternal();
-    std::pair<std::shared_ptr<IWifiStaIface>, ndk::ScopedAStatus> getStaIfaceInternal(
-            const std::string& ifname);
-    ndk::ScopedAStatus removeStaIfaceInternal(const std::string& ifname);
-    std::pair<std::shared_ptr<IWifiRttController>, ndk::ScopedAStatus> createRttControllerInternal(
-            const std::shared_ptr<IWifiStaIface>& bound_iface);
-    std::pair<std::vector<WifiDebugRingBufferStatus>, ndk::ScopedAStatus>
-    getDebugRingBuffersStatusInternal();
-    ndk::ScopedAStatus startLoggingToDebugRingBufferInternal(
-            const std::string& ring_name, WifiDebugRingBufferVerboseLevel verbose_level,
-            uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes);
-    ndk::ScopedAStatus forceDumpToDebugRingBufferInternal(const std::string& ring_name);
-    ndk::ScopedAStatus flushRingBufferToFileInternal();
-    ndk::ScopedAStatus stopLoggingToDebugRingBufferInternal();
-    std::pair<WifiDebugHostWakeReasonStats, ndk::ScopedAStatus>
-    getDebugHostWakeReasonStatsInternal();
-    ndk::ScopedAStatus enableDebugErrorAlertsInternal(bool enable);
-    ndk::ScopedAStatus selectTxPowerScenarioInternal(IWifiChip::TxPowerScenario scenario);
-    ndk::ScopedAStatus resetTxPowerScenarioInternal();
-    ndk::ScopedAStatus setLatencyModeInternal(IWifiChip::LatencyMode mode);
-    ndk::ScopedAStatus setMultiStaPrimaryConnectionInternal(const std::string& ifname);
-    ndk::ScopedAStatus setMultiStaUseCaseInternal(IWifiChip::MultiStaUseCase use_case);
-    ndk::ScopedAStatus setCoexUnsafeChannelsInternal(
-            std::vector<IWifiChip::CoexUnsafeChannel> unsafe_channels,
-            CoexRestriction restrictions);
-    ndk::ScopedAStatus setCountryCodeInternal(const std::array<uint8_t, 2>& in_code);
-    std::pair<std::vector<WifiUsableChannel>, ndk::ScopedAStatus> getUsableChannelsInternal(
-            WifiBand band, WifiIfaceMode ifaceModeMask, UsableChannelFilter filterMask);
-    ndk::ScopedAStatus handleChipConfiguration(std::unique_lock<std::recursive_mutex>* lock,
-                                               int32_t mode_id);
-    ndk::ScopedAStatus registerDebugRingBufferCallback();
-    ndk::ScopedAStatus registerRadioModeChangeCallback();
-
-    std::vector<ChipConcurrencyCombination> getCurrentModeConcurrencyCombinations();
-    std::map<IfaceConcurrencyType, size_t> getCurrentConcurrencyCombination();
-    std::vector<std::map<IfaceConcurrencyType, size_t>> expandConcurrencyCombinations(
-            const ChipConcurrencyCombination& combination);
-    bool canExpandedConcurrencyComboSupportConcurrencyTypeWithCurrentTypes(
-            const std::map<IfaceConcurrencyType, size_t>& expanded_combo,
-            IfaceConcurrencyType requested_type);
-    bool canCurrentModeSupportConcurrencyTypeWithCurrentTypes(IfaceConcurrencyType requested_type);
-    bool canExpandedConcurrencyComboSupportConcurrencyCombo(
-            const std::map<IfaceConcurrencyType, size_t>& expanded_combo,
-            const std::map<IfaceConcurrencyType, size_t>& req_combo);
-    bool canCurrentModeSupportConcurrencyCombo(
-            const std::map<IfaceConcurrencyType, size_t>& req_combo);
-    bool canCurrentModeSupportConcurrencyType(IfaceConcurrencyType requested_type);
-
-    bool isValidModeId(int32_t mode_id);
-    bool isStaApConcurrencyAllowedInCurrentMode();
-    bool isDualStaConcurrencyAllowedInCurrentMode();
-    uint32_t startIdxOfApIface();
-    std::string getFirstActiveWlanIfaceName();
-    std::string allocateApOrStaIfaceName(IfaceType type, uint32_t start_idx);
-    std::string allocateApIfaceName();
-    std::vector<std::string> allocateBridgedApInstanceNames();
-    std::string allocateStaIfaceName();
-    bool writeRingbufferFilesInternal();
-    std::string getWlanIfaceNameWithType(IfaceType type, unsigned idx);
-    void invalidateAndClearBridgedApAll();
-    void invalidateAndClearBridgedAp(const std::string& br_name);
-    bool findUsingNameFromBridgedApInstances(const std::string& name);
-    ndk::ScopedAStatus triggerSubsystemRestartInternal();
-    std::pair<WifiRadioCombinationMatrix, ndk::ScopedAStatus>
-    getSupportedRadioCombinationsMatrixInternal();
-    void setWeakPtr(std::weak_ptr<WifiChip> ptr);
-
-    int32_t chip_id_;
-    std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
-    std::weak_ptr<mode_controller::WifiModeController> mode_controller_;
-    std::shared_ptr<iface_util::WifiIfaceUtil> iface_util_;
-    std::vector<std::shared_ptr<WifiApIface>> ap_ifaces_;
-    std::vector<std::shared_ptr<WifiNanIface>> nan_ifaces_;
-    std::vector<std::shared_ptr<WifiP2pIface>> p2p_ifaces_;
-    std::vector<std::shared_ptr<WifiStaIface>> sta_ifaces_;
-    std::vector<std::shared_ptr<WifiRttController>> rtt_controllers_;
-    std::map<std::string, Ringbuffer> ringbuffer_map_;
-    bool is_valid_;
-    // Members pertaining to chip configuration.
-    int32_t current_mode_id_;
-    std::mutex lock_t;
-    std::vector<IWifiChip::ChipMode> modes_;
-    // The legacy ring buffer callback API has only a global callback
-    // registration mechanism. Use this to check if we have already
-    // registered a callback.
-    bool debug_ring_buffer_cb_registered_;
-    aidl_callback_util::AidlCallbackHandler<IWifiChipEventCallback> event_cb_handler_;
-    std::weak_ptr<WifiChip> weak_ptr_this_;
-
-    const std::function<void(const std::string&)> subsystemCallbackHandler_;
-    std::map<std::string, std::vector<std::string>> br_ifaces_ap_instances_;
-    DISALLOW_COPY_AND_ASSIGN(WifiChip);
-};
-
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
-
-#endif  // WIFI_CHIP_H_
diff --git a/wifi/aidl/default/wifi_feature_flags.cpp b/wifi/aidl/default/wifi_feature_flags.cpp
deleted file mode 100644
index 3c9f042..0000000
--- a/wifi/aidl/default/wifi_feature_flags.cpp
+++ /dev/null
@@ -1,228 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <string>
-
-#include <android-base/logging.h>
-#include <cutils/properties.h>
-
-#include "wifi_feature_flags.h"
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-namespace feature_flags {
-
-/* The chip may either have a single mode supporting any number of combinations,
- * or a fixed dual-mode (so it involves firmware loading to switch between
- * modes) setting. If there is a need to support more modes, it needs to be
- * implemented manually in WiFi HAL (see changeFirmwareMode in
- * WifiChip::handleChipConfiguration).
- *
- * Supported combinations are defined in device's makefile, for example:
- *    WIFI_HAL_INTERFACE_COMBINATIONS := {{{STA, AP}, 1}, {{P2P, NAN}, 1}},
- *    WIFI_HAL_INTERFACE_COMBINATIONS += {{{STA}, 1}, {{AP}, 2}}
- * What this means:
- *    Interface concurrency combination 1: 1 STA or AP and 1 P2P or NAN concurrent iface
- *                             operations.
- *    Interface concurrency combination 2: 1 STA and 2 AP concurrent iface operations.
- *
- * For backward compatibility, the following makefile flags can be used to
- * generate combinations list:
- *  - WIFI_HIDL_FEATURE_DUAL_INTERFACE
- *  - WIFI_HIDL_FEATURE_DISABLE_AP
- *  - WIFI_HIDL_FEATURE_AWARE
- * However, they are ignored if WIFI_HAL_INTERFACE_COMBINATIONS was provided.
- * With WIFI_HIDL_FEATURE_DUAL_INTERFACE flag set, there is a single mode with
- * two concurrency combinations:
- *    Interface Concurrency Combination 1: Will support 1 STA and 1 P2P or NAN (optional)
- *                             concurrent iface operations.
- *    Interface Concurrency Combination 2: Will support 1 STA and 1 AP concurrent
- *                             iface operations.
- *
- * The only dual-mode configuration supported is for alternating STA and AP
- * mode, that may involve firmware reloading. In such case, there are 2 separate
- * modes of operation with 1 concurrency combination each:
- *    Mode 1 (STA mode): Will support 1 STA and 1 P2P or NAN (optional)
- *                       concurrent iface operations.
- *    Mode 2 (AP mode): Will support 1 AP iface operation.
- *
- * If Aware is enabled, the concurrency combination will be modified to support either
- * P2P or NAN in place of just P2P.
- */
-// clang-format off
-#ifdef WIFI_HAL_INTERFACE_COMBINATIONS
-constexpr int kMainModeId = chip_mode_ids::kV3;
-#elif defined(WIFI_HIDL_FEATURE_DUAL_INTERFACE)
-// former V2 (fixed dual interface) setup expressed as V3
-constexpr int kMainModeId = chip_mode_ids::kV3;
-#  ifdef WIFI_HIDL_FEATURE_DISABLE_AP
-#    ifdef WIFI_HIDL_FEATURE_AWARE
-//     1 STA + 1 of (P2P or NAN)
-#      define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{P2P, NAN}, 1}}
-#    else
-//     1 STA + 1 P2P
-#      define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{P2P}, 1}}
-#    endif
-#  else
-#    ifdef WIFI_HIDL_FEATURE_AWARE
-//     (1 STA + 1 AP) or (1 STA + 1 of (P2P or NAN))
-#      define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{AP}, 1}},\
-                                              {{{STA}, 1}, {{P2P, NAN}, 1}}
-#    else
-//     (1 STA + 1 AP) or (1 STA + 1 P2P)
-#      define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{AP}, 1}},\
-                                              {{{STA}, 1}, {{P2P}, 1}}
-#    endif
-#  endif
-#else
-// V1 (fixed single interface, dual-mode chip)
-constexpr int kMainModeId = chip_mode_ids::kV1Sta;
-#  ifdef WIFI_HIDL_FEATURE_AWARE
-//   1 STA + 1 of (P2P or NAN)
-#    define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{P2P, NAN}, 1}}
-#  else
-//   1 STA + 1 P2P
-#    define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{P2P}, 1}}
-#  endif
-
-#  ifndef WIFI_HIDL_FEATURE_DISABLE_AP
-#    define WIFI_HAL_INTERFACE_COMBINATIONS_AP {{{AP}, 1}}
-#  endif
-#endif
-// clang-format on
-
-// Convert from the legacy format (used by the WIFI_HAL_INTERFACE_COMBINATIONS
-// config variable) to a list of ChipConcurrencyCombination objects.
-std::vector<IWifiChip::ChipConcurrencyCombination> legacyToChipConcurrencyComboList(
-        std::vector<std::vector<IWifiChip::ChipConcurrencyCombinationLimit>> legacyLimits) {
-    std::vector<IWifiChip::ChipConcurrencyCombination> combos;
-    for (auto& legacyLimit : legacyLimits) {
-        IWifiChip::ChipConcurrencyCombination combo = {legacyLimit};
-        combos.push_back(combo);
-    }
-    return combos;
-}
-
-#define STA IfaceConcurrencyType::STA
-#define AP IfaceConcurrencyType::AP
-#define AP_BRIDGED IfaceConcurrencyType::AP_BRIDGED
-#define P2P IfaceConcurrencyType::P2P
-#define NAN IfaceConcurrencyType::NAN_IFACE
-static const std::vector<IWifiChip::ChipMode> kChipModesPrimary{
-        {kMainModeId, legacyToChipConcurrencyComboList({WIFI_HAL_INTERFACE_COMBINATIONS})},
-#ifdef WIFI_HAL_INTERFACE_COMBINATIONS_AP
-        {chip_mode_ids::kV1Ap,
-         legacyToChipConcurrencyComboList({WIFI_HAL_INTERFACE_COMBINATIONS_AP})},
-#endif
-};
-
-static const std::vector<IWifiChip::ChipMode> kChipModesSecondary{
-#ifdef WIFI_HAL_INTERFACE_COMBINATIONS_SECONDARY_CHIP
-        {chip_mode_ids::kV3,
-         legacyToChipConcurrencyComboList({WIFI_HAL_INTERFACE_COMBINATIONS_SECONDARY_CHIP})},
-#endif
-};
-
-constexpr char kDebugPresetInterfaceCombinationIdxProperty[] =
-        "persist.vendor.debug.wifi.hal.preset_interface_combination_idx";
-// List of pre-defined concurrency combinations that can be enabled at runtime via
-// setting the property: "kDebugPresetInterfaceCombinationIdxProperty" to the
-// corresponding index value.
-static const std::vector<std::pair<std::string, std::vector<IWifiChip::ChipMode>>> kDebugChipModes{
-        // Legacy combination - No STA/AP concurrencies.
-        // 0 - (1 AP) or (1 STA + 1 of (P2P or NAN))
-        {"No STA/AP Concurrency",
-         {{kMainModeId,
-           legacyToChipConcurrencyComboList({{{{AP}, 1}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
-
-        // STA + AP concurrency
-        // 1 - (1 STA + 1 AP) or (1 STA + 1 of (P2P or NAN))
-        {"STA + AP Concurrency",
-         {{kMainModeId, legacyToChipConcurrencyComboList(
-                                {{{{STA}, 1}, {{AP}, 1}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
-
-        // STA + STA concurrency
-        // 2 - (1 STA + 1 AP) or (2 STA + 1 of (P2P or NAN))
-        {"Dual STA Concurrency",
-         {{kMainModeId, legacyToChipConcurrencyComboList(
-                                {{{{STA}, 1}, {{AP}, 1}}, {{{STA}, 2}, {{P2P, NAN}, 1}}})}}},
-
-        // AP + AP + STA concurrency
-        // 3 - (1 STA + 2 AP) or (1 STA + 1 of (P2P or NAN))
-        {"Dual AP Concurrency",
-         {{kMainModeId, legacyToChipConcurrencyComboList(
-                                {{{{STA}, 1}, {{AP}, 2}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
-
-        // STA + STA concurrency and AP + AP + STA concurrency
-        // 4 - (1 STA + 2 AP) or (2 STA + 1 of (P2P or NAN))
-        {"Dual STA & Dual AP Concurrency",
-         {{kMainModeId, legacyToChipConcurrencyComboList(
-                                {{{{STA}, 1}, {{AP}, 2}}, {{{STA}, 2}, {{P2P, NAN}, 1}}})}}},
-
-        // STA + STA concurrency
-        // 5 - (1 STA + 1 AP (bridged or single) | P2P | NAN), or (2 STA))
-        {"Dual STA or STA plus single other interface",
-         {{kMainModeId, legacyToChipConcurrencyComboList(
-                                {{{{STA}, 1}, {{P2P, NAN, AP, AP_BRIDGED}, 1}}, {{{STA}, 2}}})}}}};
-
-#undef STA
-#undef AP
-#undef AP_BRIDGED
-#undef P2P
-#undef NAN
-
-#ifdef WIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION
-#pragma message                                                                   \
-        "WIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION is deprecated; override " \
-        "'config_wifi_ap_randomization_supported' in "                            \
-        "frameworks/base/core/res/res/values/config.xml in the device overlay "   \
-        "instead"
-#endif  // WIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION
-
-WifiFeatureFlags::WifiFeatureFlags() {}
-
-std::vector<IWifiChip::ChipMode> WifiFeatureFlags::getChipModesForPrimary() {
-    std::array<char, PROPERTY_VALUE_MAX> buffer;
-    auto res = property_get(kDebugPresetInterfaceCombinationIdxProperty, buffer.data(), nullptr);
-    // Debug property not set, use the device preset concurrency combination.
-    if (res <= 0) return kChipModesPrimary;
-
-    // Debug property set, use one of the debug preset concurrency combination.
-    unsigned long idx = std::stoul(buffer.data());
-    if (idx >= kDebugChipModes.size()) {
-        LOG(ERROR) << "Invalid index set in property: "
-                   << kDebugPresetInterfaceCombinationIdxProperty;
-        return kChipModesPrimary;
-    }
-    std::string name;
-    std::vector<IWifiChip::ChipMode> chip_modes;
-    std::tie(name, chip_modes) = kDebugChipModes[idx];
-    LOG(INFO) << "Using debug chip mode: <" << name
-              << "> set via property: " << kDebugPresetInterfaceCombinationIdxProperty;
-    return chip_modes;
-}
-
-std::vector<IWifiChip::ChipMode> WifiFeatureFlags::getChipModes(bool is_primary) {
-    return (is_primary) ? getChipModesForPrimary() : kChipModesSecondary;
-}
-
-}  // namespace feature_flags
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/wifi_nan_iface.cpp b/wifi/aidl/default/wifi_nan_iface.cpp
deleted file mode 100644
index 9edef09..0000000
--- a/wifi/aidl/default/wifi_nan_iface.cpp
+++ /dev/null
@@ -1,751 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "wifi_nan_iface.h"
-
-#include <android-base/logging.h>
-
-#include "aidl_return_util.h"
-#include "aidl_struct_util.h"
-#include "wifi_status_util.h"
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-using aidl_return_util::validateAndCall;
-
-WifiNanIface::WifiNanIface(const std::string& ifname, bool is_dedicated_iface,
-                           const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-                           const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
-    : ifname_(ifname),
-      is_dedicated_iface_(is_dedicated_iface),
-      legacy_hal_(legacy_hal),
-      iface_util_(iface_util),
-      is_valid_(true) {}
-
-std::shared_ptr<WifiNanIface> WifiNanIface::create(
-        const std::string& ifname, bool is_dedicated_iface,
-        const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-        const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util) {
-    std::shared_ptr<WifiNanIface> ptr = ndk::SharedRefBase::make<WifiNanIface>(
-            ifname, is_dedicated_iface, legacy_hal, iface_util);
-    if (is_dedicated_iface) {
-        // If using a dedicated iface, set the iface up first.
-        if (!iface_util.lock()->setUpState(ifname, true)) {
-            // Fatal failure, invalidate the iface object.
-            ptr->invalidate();
-            return nullptr;
-        }
-    }
-    std::weak_ptr<WifiNanIface> weak_ptr_this(ptr);
-    ptr->setWeakPtr(weak_ptr_this);
-    ptr->registerCallbackHandlers();
-    return ptr;
-}
-
-void WifiNanIface::registerCallbackHandlers() {
-    // Register all the callbacks here. These should be valid for the lifetime
-    // of the object. Whenever the mode changes legacy HAL will remove
-    // all of these callbacks.
-    legacy_hal::NanCallbackHandlers callback_handlers;
-    std::weak_ptr<WifiNanIface> weak_ptr_this = weak_ptr_this_;
-
-    // Callback for response.
-    callback_handlers.on_notify_response = [weak_ptr_this](legacy_hal::transaction_id id,
-                                                           const legacy_hal::NanResponseMsg& msg) {
-        const auto shared_ptr_this = weak_ptr_this.lock();
-        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-            LOG(ERROR) << "Callback invoked on an invalid object";
-            return;
-        }
-        NanStatus nanStatus;
-        if (!aidl_struct_util::convertLegacyNanResponseHeaderToAidl(msg, &nanStatus)) {
-            LOG(ERROR) << "Failed to convert nan response header";
-            return;
-        }
-
-        switch (msg.response_type) {
-            case legacy_hal::NAN_RESPONSE_ENABLED: {
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->notifyEnableResponse(id, nanStatus).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-                break;
-            }
-            case legacy_hal::NAN_RESPONSE_DISABLED: {
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->notifyDisableResponse(id, nanStatus).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-                break;
-            }
-            case legacy_hal::NAN_RESPONSE_PUBLISH: {
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->notifyStartPublishResponse(id, nanStatus,
-                                                              msg.body.publish_response.publish_id)
-                                 .isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-                break;
-            }
-            case legacy_hal::NAN_RESPONSE_PUBLISH_CANCEL: {
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->notifyStopPublishResponse(id, nanStatus).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-                break;
-            }
-            case legacy_hal::NAN_RESPONSE_TRANSMIT_FOLLOWUP: {
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->notifyTransmitFollowupResponse(id, nanStatus).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-                break;
-            }
-            case legacy_hal::NAN_RESPONSE_SUBSCRIBE: {
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->notifyStartSubscribeResponse(
-                                         id, nanStatus, msg.body.subscribe_response.subscribe_id)
-                                 .isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-                break;
-            }
-            case legacy_hal::NAN_RESPONSE_SUBSCRIBE_CANCEL: {
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->notifyStopSubscribeResponse(id, nanStatus).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-                break;
-            }
-            case legacy_hal::NAN_RESPONSE_CONFIG: {
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->notifyConfigResponse(id, nanStatus).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-                break;
-            }
-            case legacy_hal::NAN_GET_CAPABILITIES: {
-                NanCapabilities aidl_struct;
-                if (!aidl_struct_util::convertLegacyNanCapabilitiesResponseToAidl(
-                            msg.body.nan_capabilities, &aidl_struct)) {
-                    LOG(ERROR) << "Failed to convert nan capabilities response";
-                    return;
-                }
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->notifyCapabilitiesResponse(id, nanStatus, aidl_struct).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-                break;
-            }
-            case legacy_hal::NAN_DP_INTERFACE_CREATE: {
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->notifyCreateDataInterfaceResponse(id, nanStatus).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-                break;
-            }
-            case legacy_hal::NAN_DP_INTERFACE_DELETE: {
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->notifyDeleteDataInterfaceResponse(id, nanStatus).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-                break;
-            }
-            case legacy_hal::NAN_DP_INITIATOR_RESPONSE: {
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->notifyInitiateDataPathResponse(
-                                         id, nanStatus,
-                                         msg.body.data_request_response.ndp_instance_id)
-                                 .isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-                break;
-            }
-            case legacy_hal::NAN_DP_RESPONDER_RESPONSE: {
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->notifyRespondToDataPathIndicationResponse(id, nanStatus)
-                                 .isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-                break;
-            }
-            case legacy_hal::NAN_DP_END: {
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->notifyTerminateDataPathResponse(id, nanStatus).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-                break;
-            }
-            case legacy_hal::NAN_RESPONSE_BEACON_SDF_PAYLOAD:
-            /* fall through */
-            case legacy_hal::NAN_RESPONSE_TCA:
-            /* fall through */
-            case legacy_hal::NAN_RESPONSE_STATS:
-            /* fall through */
-            case legacy_hal::NAN_RESPONSE_ERROR:
-            /* fall through */
-            default:
-                LOG(ERROR) << "Unknown or unhandled response type: " << msg.response_type;
-                return;
-        }
-    };
-
-    callback_handlers.on_event_disc_eng_event = [weak_ptr_this](
-                                                        const legacy_hal::NanDiscEngEventInd& msg) {
-        const auto shared_ptr_this = weak_ptr_this.lock();
-        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-            LOG(ERROR) << "Callback invoked on an invalid object";
-            return;
-        }
-        NanClusterEventInd aidl_struct;
-        // event types defined identically - hence can be cast
-        aidl_struct.eventType = (NanClusterEventType)msg.event_type;
-        aidl_struct.addr = std::array<uint8_t, 6>();
-        std::copy(msg.data.mac_addr.addr, msg.data.mac_addr.addr + 6, std::begin(aidl_struct.addr));
-
-        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-            if (!callback->eventClusterEvent(aidl_struct).isOk()) {
-                LOG(ERROR) << "Failed to invoke the callback";
-            }
-        }
-    };
-
-    callback_handlers.on_event_disabled = [weak_ptr_this](const legacy_hal::NanDisabledInd& msg) {
-        const auto shared_ptr_this = weak_ptr_this.lock();
-        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-            LOG(ERROR) << "Callback invoked on an invalid object";
-            return;
-        }
-        NanStatus status;
-        aidl_struct_util::convertToNanStatus(msg.reason, msg.nan_reason, sizeof(msg.nan_reason),
-                                             &status);
-
-        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-            if (!callback->eventDisabled(status).isOk()) {
-                LOG(ERROR) << "Failed to invoke the callback";
-            }
-        }
-    };
-
-    callback_handlers.on_event_publish_terminated =
-            [weak_ptr_this](const legacy_hal::NanPublishTerminatedInd& msg) {
-                const auto shared_ptr_this = weak_ptr_this.lock();
-                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-                    LOG(ERROR) << "Callback invoked on an invalid object";
-                    return;
-                }
-                NanStatus status;
-                aidl_struct_util::convertToNanStatus(msg.reason, msg.nan_reason,
-                                                     sizeof(msg.nan_reason), &status);
-
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->eventPublishTerminated(msg.publish_id, status).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-            };
-
-    callback_handlers.on_event_subscribe_terminated =
-            [weak_ptr_this](const legacy_hal::NanSubscribeTerminatedInd& msg) {
-                const auto shared_ptr_this = weak_ptr_this.lock();
-                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-                    LOG(ERROR) << "Callback invoked on an invalid object";
-                    return;
-                }
-                NanStatus status;
-                aidl_struct_util::convertToNanStatus(msg.reason, msg.nan_reason,
-                                                     sizeof(msg.nan_reason), &status);
-
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->eventSubscribeTerminated(msg.subscribe_id, status).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-            };
-
-    callback_handlers.on_event_match = [weak_ptr_this](const legacy_hal::NanMatchInd& msg) {
-        const auto shared_ptr_this = weak_ptr_this.lock();
-        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-            LOG(ERROR) << "Callback invoked on an invalid object";
-            return;
-        }
-        NanMatchInd aidl_struct;
-        if (!aidl_struct_util::convertLegacyNanMatchIndToAidl(msg, &aidl_struct)) {
-            LOG(ERROR) << "Failed to convert nan capabilities response";
-            return;
-        }
-
-        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-            if (!callback->eventMatch(aidl_struct).isOk()) {
-                LOG(ERROR) << "Failed to invoke the callback";
-            }
-        }
-    };
-
-    callback_handlers.on_event_match_expired = [weak_ptr_this](
-                                                       const legacy_hal::NanMatchExpiredInd& msg) {
-        const auto shared_ptr_this = weak_ptr_this.lock();
-        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-            LOG(ERROR) << "Callback invoked on an invalid object";
-            return;
-        }
-        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-            if (!callback->eventMatchExpired(msg.publish_subscribe_id, msg.requestor_instance_id)
-                         .isOk()) {
-                LOG(ERROR) << "Failed to invoke the callback";
-            }
-        }
-    };
-
-    callback_handlers.on_event_followup = [weak_ptr_this](const legacy_hal::NanFollowupInd& msg) {
-        const auto shared_ptr_this = weak_ptr_this.lock();
-        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-            LOG(ERROR) << "Callback invoked on an invalid object";
-            return;
-        }
-        NanFollowupReceivedInd aidl_struct;
-        if (!aidl_struct_util::convertLegacyNanFollowupIndToAidl(msg, &aidl_struct)) {
-            LOG(ERROR) << "Failed to convert nan capabilities response";
-            return;
-        }
-
-        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-            if (!callback->eventFollowupReceived(aidl_struct).isOk()) {
-                LOG(ERROR) << "Failed to invoke the callback";
-            }
-        }
-    };
-
-    callback_handlers.on_event_transmit_follow_up =
-            [weak_ptr_this](const legacy_hal::NanTransmitFollowupInd& msg) {
-                const auto shared_ptr_this = weak_ptr_this.lock();
-                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-                    LOG(ERROR) << "Callback invoked on an invalid object";
-                    return;
-                }
-                NanStatus status;
-                aidl_struct_util::convertToNanStatus(msg.reason, msg.nan_reason,
-                                                     sizeof(msg.nan_reason), &status);
-
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->eventTransmitFollowup(msg.id, status).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-            };
-
-    callback_handlers.on_event_data_path_request =
-            [weak_ptr_this](const legacy_hal::NanDataPathRequestInd& msg) {
-                const auto shared_ptr_this = weak_ptr_this.lock();
-                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-                    LOG(ERROR) << "Callback invoked on an invalid object";
-                    return;
-                }
-                NanDataPathRequestInd aidl_struct;
-                if (!aidl_struct_util::convertLegacyNanDataPathRequestIndToAidl(msg,
-                                                                                &aidl_struct)) {
-                    LOG(ERROR) << "Failed to convert nan capabilities response";
-                    return;
-                }
-
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->eventDataPathRequest(aidl_struct).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-            };
-
-    callback_handlers.on_event_data_path_confirm =
-            [weak_ptr_this](const legacy_hal::NanDataPathConfirmInd& msg) {
-                const auto shared_ptr_this = weak_ptr_this.lock();
-                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-                    LOG(ERROR) << "Callback invoked on an invalid object";
-                    return;
-                }
-                NanDataPathConfirmInd aidl_struct;
-                if (!aidl_struct_util::convertLegacyNanDataPathConfirmIndToAidl(msg,
-                                                                                &aidl_struct)) {
-                    LOG(ERROR) << "Failed to convert nan capabilities response";
-                    return;
-                }
-
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->eventDataPathConfirm(aidl_struct).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-            };
-
-    callback_handlers.on_event_data_path_end =
-            [weak_ptr_this](const legacy_hal::NanDataPathEndInd& msg) {
-                const auto shared_ptr_this = weak_ptr_this.lock();
-                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-                    LOG(ERROR) << "Callback invoked on an invalid object";
-                    return;
-                }
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    for (int i = 0; i < msg.num_ndp_instances; ++i) {
-                        if (!callback->eventDataPathTerminated(msg.ndp_instance_id[i]).isOk()) {
-                            LOG(ERROR) << "Failed to invoke the callback";
-                        }
-                    }
-                }
-            };
-
-    callback_handlers.on_event_beacon_sdf_payload =
-            [](const legacy_hal::NanBeaconSdfPayloadInd& /* msg */) {
-                LOG(ERROR) << "on_event_beacon_sdf_payload - should not be called";
-            };
-
-    callback_handlers.on_event_range_request = [](const legacy_hal::NanRangeRequestInd& /* msg */) {
-        LOG(ERROR) << "on_event_range_request - should not be called";
-    };
-
-    callback_handlers.on_event_range_report = [](const legacy_hal::NanRangeReportInd& /* msg */) {
-        LOG(ERROR) << "on_event_range_report - should not be called";
-    };
-
-    callback_handlers.on_event_schedule_update =
-            [weak_ptr_this](const legacy_hal::NanDataPathScheduleUpdateInd& msg) {
-                const auto shared_ptr_this = weak_ptr_this.lock();
-                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-                    LOG(ERROR) << "Callback invoked on an invalid object";
-                    return;
-                }
-                NanDataPathScheduleUpdateInd aidl_struct;
-                if (!aidl_struct_util::convertLegacyNanDataPathScheduleUpdateIndToAidl(
-                            msg, &aidl_struct)) {
-                    LOG(ERROR) << "Failed to convert nan capabilities response";
-                    return;
-                }
-
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->eventDataPathScheduleUpdate(aidl_struct).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-            };
-
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->nanRegisterCallbackHandlers(ifname_, callback_handlers);
-    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
-        LOG(ERROR) << "Failed to register nan callbacks. Invalidating object";
-        invalidate();
-    }
-
-    // Register for iface state toggle events.
-    iface_util::IfaceEventHandlers event_handlers = {};
-    event_handlers.on_state_toggle_off_on = [weak_ptr_this](const std::string& /* iface_name */) {
-        const auto shared_ptr_this = weak_ptr_this.lock();
-        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-            LOG(ERROR) << "Callback invoked on an invalid object";
-            return;
-        }
-        // Tell framework that NAN has been disabled.
-        NanStatus status = {NanStatusCode::UNSUPPORTED_CONCURRENCY_NAN_DISABLED, ""};
-        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-            if (!callback->eventDisabled(status).isOk()) {
-                LOG(ERROR) << "Failed to invoke the callback";
-            }
-        }
-    };
-    iface_util_.lock()->registerIfaceEventHandlers(ifname_, event_handlers);
-}
-
-void WifiNanIface::setWeakPtr(std::weak_ptr<WifiNanIface> ptr) {
-    weak_ptr_this_ = ptr;
-}
-
-void WifiNanIface::invalidate() {
-    if (!isValid()) {
-        return;
-    }
-    // send commands to HAL to actually disable and destroy interfaces
-    legacy_hal_.lock()->nanDisableRequest(ifname_, 0xFFFF);
-    legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, 0xFFFE, "aware_data0");
-    legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, 0xFFFD, "aware_data1");
-    iface_util_.lock()->unregisterIfaceEventHandlers(ifname_);
-    legacy_hal_.reset();
-    event_cb_handler_.invalidate();
-    is_valid_ = false;
-    if (is_dedicated_iface_) {
-        // If using a dedicated iface, set the iface down.
-        iface_util_.lock()->setUpState(ifname_, false);
-    }
-}
-
-bool WifiNanIface::isValid() {
-    return is_valid_;
-}
-
-std::string WifiNanIface::getName() {
-    return ifname_;
-}
-
-std::set<std::shared_ptr<IWifiNanIfaceEventCallback>> WifiNanIface::getEventCallbacks() {
-    LOG(ERROR) << "Using original getEventCallbacks";
-    return event_cb_handler_.getCallbacks();
-}
-
-ndk::ScopedAStatus WifiNanIface::getName(std::string* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::getNameInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiNanIface::registerEventCallback(
-        const std::shared_ptr<IWifiNanIfaceEventCallback>& callback) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::registerEventCallbackInternal, callback);
-}
-
-ndk::ScopedAStatus WifiNanIface::getCapabilitiesRequest(char16_t in_cmdId) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::getCapabilitiesRequestInternal, in_cmdId);
-}
-
-ndk::ScopedAStatus WifiNanIface::enableRequest(char16_t in_cmdId, const NanEnableRequest& in_msg1,
-                                               const NanConfigRequestSupplemental& in_msg2) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::enableRequestInternal, in_cmdId, in_msg1, in_msg2);
-}
-
-ndk::ScopedAStatus WifiNanIface::configRequest(char16_t in_cmdId, const NanConfigRequest& in_msg1,
-                                               const NanConfigRequestSupplemental& in_msg2) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::configRequestInternal, in_cmdId, in_msg1, in_msg2);
-}
-
-ndk::ScopedAStatus WifiNanIface::disableRequest(char16_t in_cmdId) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::disableRequestInternal, in_cmdId);
-}
-
-ndk::ScopedAStatus WifiNanIface::startPublishRequest(char16_t in_cmdId,
-                                                     const NanPublishRequest& in_msg) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::startPublishRequestInternal, in_cmdId, in_msg);
-}
-
-ndk::ScopedAStatus WifiNanIface::stopPublishRequest(char16_t in_cmdId, int8_t in_sessionId) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::stopPublishRequestInternal, in_cmdId, in_sessionId);
-}
-
-ndk::ScopedAStatus WifiNanIface::startSubscribeRequest(char16_t in_cmdId,
-                                                       const NanSubscribeRequest& in_msg) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::startSubscribeRequestInternal, in_cmdId, in_msg);
-}
-
-ndk::ScopedAStatus WifiNanIface::stopSubscribeRequest(char16_t in_cmdId, int8_t in_sessionId) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::stopSubscribeRequestInternal, in_cmdId, in_sessionId);
-}
-
-ndk::ScopedAStatus WifiNanIface::transmitFollowupRequest(char16_t in_cmdId,
-                                                         const NanTransmitFollowupRequest& in_msg) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::transmitFollowupRequestInternal, in_cmdId, in_msg);
-}
-
-ndk::ScopedAStatus WifiNanIface::createDataInterfaceRequest(char16_t in_cmdId,
-                                                            const std::string& in_ifaceName) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::createDataInterfaceRequestInternal, in_cmdId,
-                           in_ifaceName);
-}
-
-ndk::ScopedAStatus WifiNanIface::deleteDataInterfaceRequest(char16_t in_cmdId,
-                                                            const std::string& in_ifaceName) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::deleteDataInterfaceRequestInternal, in_cmdId,
-                           in_ifaceName);
-}
-
-ndk::ScopedAStatus WifiNanIface::initiateDataPathRequest(char16_t in_cmdId,
-                                                         const NanInitiateDataPathRequest& in_msg) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::initiateDataPathRequestInternal, in_cmdId, in_msg);
-}
-
-ndk::ScopedAStatus WifiNanIface::respondToDataPathIndicationRequest(
-        char16_t in_cmdId, const NanRespondToDataPathIndicationRequest& in_msg) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::respondToDataPathIndicationRequestInternal, in_cmdId,
-                           in_msg);
-}
-
-ndk::ScopedAStatus WifiNanIface::terminateDataPathRequest(char16_t in_cmdId,
-                                                          int32_t in_ndpInstanceId) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiNanIface::terminateDataPathRequestInternal, in_cmdId,
-                           in_ndpInstanceId);
-}
-
-std::pair<std::string, ndk::ScopedAStatus> WifiNanIface::getNameInternal() {
-    return {ifname_, ndk::ScopedAStatus::ok()};
-}
-
-ndk::ScopedAStatus WifiNanIface::registerEventCallbackInternal(
-        const std::shared_ptr<IWifiNanIfaceEventCallback>& callback) {
-    if (!event_cb_handler_.addCallback(callback)) {
-        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
-    }
-    return ndk::ScopedAStatus::ok();
-}
-
-ndk::ScopedAStatus WifiNanIface::getCapabilitiesRequestInternal(char16_t cmd_id) {
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->nanGetCapabilities(ifname_, cmd_id);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiNanIface::enableRequestInternal(char16_t cmd_id,
-                                                       const NanEnableRequest& msg1,
-                                                       const NanConfigRequestSupplemental& msg2) {
-    legacy_hal::NanEnableRequest legacy_msg;
-    if (!aidl_struct_util::convertAidlNanEnableRequestToLegacy(msg1, msg2, &legacy_msg)) {
-        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
-    }
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->nanEnableRequest(ifname_, cmd_id, legacy_msg);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiNanIface::configRequestInternal(char16_t cmd_id,
-                                                       const NanConfigRequest& msg1,
-                                                       const NanConfigRequestSupplemental& msg2) {
-    legacy_hal::NanConfigRequest legacy_msg;
-    if (!aidl_struct_util::convertAidlNanConfigRequestToLegacy(msg1, msg2, &legacy_msg)) {
-        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
-    }
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->nanConfigRequest(ifname_, cmd_id, legacy_msg);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiNanIface::disableRequestInternal(char16_t cmd_id) {
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->nanDisableRequest(ifname_, cmd_id);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiNanIface::startPublishRequestInternal(char16_t cmd_id,
-                                                             const NanPublishRequest& msg) {
-    legacy_hal::NanPublishRequest legacy_msg;
-    if (!aidl_struct_util::convertAidlNanPublishRequestToLegacy(msg, &legacy_msg)) {
-        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
-    }
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->nanPublishRequest(ifname_, cmd_id, legacy_msg);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiNanIface::stopPublishRequestInternal(char16_t cmd_id, int8_t sessionId) {
-    legacy_hal::NanPublishCancelRequest legacy_msg;
-    legacy_msg.publish_id = sessionId;
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->nanPublishCancelRequest(ifname_, cmd_id, legacy_msg);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiNanIface::startSubscribeRequestInternal(char16_t cmd_id,
-                                                               const NanSubscribeRequest& msg) {
-    legacy_hal::NanSubscribeRequest legacy_msg;
-    if (!aidl_struct_util::convertAidlNanSubscribeRequestToLegacy(msg, &legacy_msg)) {
-        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
-    }
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->nanSubscribeRequest(ifname_, cmd_id, legacy_msg);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiNanIface::stopSubscribeRequestInternal(char16_t cmd_id, int8_t sessionId) {
-    legacy_hal::NanSubscribeCancelRequest legacy_msg;
-    legacy_msg.subscribe_id = sessionId;
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->nanSubscribeCancelRequest(ifname_, cmd_id, legacy_msg);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiNanIface::transmitFollowupRequestInternal(
-        char16_t cmd_id, const NanTransmitFollowupRequest& msg) {
-    legacy_hal::NanTransmitFollowupRequest legacy_msg;
-    if (!aidl_struct_util::convertAidlNanTransmitFollowupRequestToLegacy(msg, &legacy_msg)) {
-        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
-    }
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->nanTransmitFollowupRequest(ifname_, cmd_id, legacy_msg);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiNanIface::createDataInterfaceRequestInternal(char16_t cmd_id,
-                                                                    const std::string& iface_name) {
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->nanDataInterfaceCreate(ifname_, cmd_id, iface_name);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-ndk::ScopedAStatus WifiNanIface::deleteDataInterfaceRequestInternal(char16_t cmd_id,
-                                                                    const std::string& iface_name) {
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, cmd_id, iface_name);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-ndk::ScopedAStatus WifiNanIface::initiateDataPathRequestInternal(
-        char16_t cmd_id, const NanInitiateDataPathRequest& msg) {
-    legacy_hal::NanDataPathInitiatorRequest legacy_msg;
-    if (!aidl_struct_util::convertAidlNanDataPathInitiatorRequestToLegacy(msg, &legacy_msg)) {
-        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
-    }
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->nanDataRequestInitiator(ifname_, cmd_id, legacy_msg);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-ndk::ScopedAStatus WifiNanIface::respondToDataPathIndicationRequestInternal(
-        char16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg) {
-    legacy_hal::NanDataPathIndicationResponse legacy_msg;
-    if (!aidl_struct_util::convertAidlNanDataPathIndicationResponseToLegacy(msg, &legacy_msg)) {
-        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
-    }
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->nanDataIndicationResponse(ifname_, cmd_id, legacy_msg);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-ndk::ScopedAStatus WifiNanIface::terminateDataPathRequestInternal(char16_t cmd_id,
-                                                                  int32_t ndpInstanceId) {
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->nanDataEnd(ifname_, cmd_id, ndpInstanceId);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/wifi_nan_iface.h b/wifi/aidl/default/wifi_nan_iface.h
deleted file mode 100644
index 1018905..0000000
--- a/wifi/aidl/default/wifi_nan_iface.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef WIFI_NAN_IFACE_H_
-#define WIFI_NAN_IFACE_H_
-
-#include <aidl/android/hardware/wifi/BnWifiNanIface.h>
-#include <aidl/android/hardware/wifi/IWifiNanIfaceEventCallback.h>
-#include <android-base/macros.h>
-
-#include "aidl_callback_util.h"
-#include "wifi_iface_util.h"
-#include "wifi_legacy_hal.h"
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-
-/**
- * AIDL interface object used to control a NAN Iface instance.
- */
-class WifiNanIface : public BnWifiNanIface {
-  public:
-    WifiNanIface(const std::string& ifname, bool is_dedicated_iface,
-                 const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-                 const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
-
-    // Factory method - use instead of default constructor.
-    static std::shared_ptr<WifiNanIface> create(
-            const std::string& ifname, bool is_dedicated_iface,
-            const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-            const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
-
-    // Refer to |WifiChip::invalidate()|.
-    void invalidate();
-    bool isValid();
-    std::string getName();
-
-    // AIDL methods exposed.
-    ndk::ScopedAStatus getName(std::string* _aidl_return) override;
-    ndk::ScopedAStatus registerEventCallback(
-            const std::shared_ptr<IWifiNanIfaceEventCallback>& in_callback) override;
-    ndk::ScopedAStatus getCapabilitiesRequest(char16_t in_cmdId) override;
-    ndk::ScopedAStatus enableRequest(char16_t in_cmdId, const NanEnableRequest& in_msg1,
-                                     const NanConfigRequestSupplemental& in_msg2) override;
-    ndk::ScopedAStatus configRequest(char16_t in_cmdId, const NanConfigRequest& in_msg1,
-                                     const NanConfigRequestSupplemental& in_msg2) override;
-    ndk::ScopedAStatus disableRequest(char16_t in_cmdId) override;
-    ndk::ScopedAStatus startPublishRequest(char16_t in_cmdId,
-                                           const NanPublishRequest& in_msg) override;
-    ndk::ScopedAStatus stopPublishRequest(char16_t in_cmdId, int8_t in_sessionId) override;
-    ndk::ScopedAStatus startSubscribeRequest(char16_t in_cmdId,
-                                             const NanSubscribeRequest& in_msg) override;
-    ndk::ScopedAStatus stopSubscribeRequest(char16_t in_cmdId, int8_t in_sessionId) override;
-    ndk::ScopedAStatus transmitFollowupRequest(char16_t in_cmdId,
-                                               const NanTransmitFollowupRequest& in_msg) override;
-    ndk::ScopedAStatus createDataInterfaceRequest(char16_t in_cmdId,
-                                                  const std::string& in_ifaceName) override;
-    ndk::ScopedAStatus deleteDataInterfaceRequest(char16_t in_cmdId,
-                                                  const std::string& in_ifaceName) override;
-    ndk::ScopedAStatus initiateDataPathRequest(char16_t in_cmdId,
-                                               const NanInitiateDataPathRequest& in_msg) override;
-    ndk::ScopedAStatus respondToDataPathIndicationRequest(
-            char16_t in_cmdId, const NanRespondToDataPathIndicationRequest& in_msg) override;
-    ndk::ScopedAStatus terminateDataPathRequest(char16_t in_cmdId,
-                                                int32_t in_ndpInstanceId) override;
-
-  protected:
-    // Accessible to child class in the gTest suite.
-    void setWeakPtr(std::weak_ptr<WifiNanIface> ptr);
-    void registerCallbackHandlers();
-
-  private:
-    // Corresponding worker functions for the AIDL methods.
-    std::pair<std::string, ndk::ScopedAStatus> getNameInternal();
-    ndk::ScopedAStatus registerEventCallbackInternal(
-            const std::shared_ptr<IWifiNanIfaceEventCallback>& callback);
-    ndk::ScopedAStatus getCapabilitiesRequestInternal(char16_t cmd_id);
-    ndk::ScopedAStatus enableRequestInternal(char16_t cmd_id, const NanEnableRequest& msg1,
-                                             const NanConfigRequestSupplemental& msg2);
-    ndk::ScopedAStatus configRequestInternal(char16_t cmd_id, const NanConfigRequest& msg1,
-                                             const NanConfigRequestSupplemental& msg2);
-    ndk::ScopedAStatus disableRequestInternal(char16_t cmd_id);
-    ndk::ScopedAStatus startPublishRequestInternal(char16_t cmd_id, const NanPublishRequest& msg);
-    ndk::ScopedAStatus stopPublishRequestInternal(char16_t cmd_id, int8_t sessionId);
-    ndk::ScopedAStatus startSubscribeRequestInternal(char16_t cmd_id,
-                                                     const NanSubscribeRequest& msg);
-    ndk::ScopedAStatus stopSubscribeRequestInternal(char16_t cmd_id, int8_t sessionId);
-    ndk::ScopedAStatus transmitFollowupRequestInternal(char16_t cmd_id,
-                                                       const NanTransmitFollowupRequest& msg);
-    ndk::ScopedAStatus createDataInterfaceRequestInternal(char16_t cmd_id,
-                                                          const std::string& iface_name);
-    ndk::ScopedAStatus deleteDataInterfaceRequestInternal(char16_t cmd_id,
-                                                          const std::string& iface_name);
-    ndk::ScopedAStatus initiateDataPathRequestInternal(char16_t cmd_id,
-                                                       const NanInitiateDataPathRequest& msg);
-    ndk::ScopedAStatus respondToDataPathIndicationRequestInternal(
-            char16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg);
-    ndk::ScopedAStatus terminateDataPathRequestInternal(char16_t cmd_id, int32_t ndpInstanceId);
-
-    // Overridden in the gTest suite.
-    virtual std::set<std::shared_ptr<IWifiNanIfaceEventCallback>> getEventCallbacks();
-
-    std::string ifname_;
-    bool is_dedicated_iface_;
-    std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
-    std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
-    bool is_valid_;
-    std::weak_ptr<WifiNanIface> weak_ptr_this_;
-    aidl_callback_util::AidlCallbackHandler<IWifiNanIfaceEventCallback> event_cb_handler_;
-
-    DISALLOW_COPY_AND_ASSIGN(WifiNanIface);
-};
-
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
-
-#endif  // WIFI_NAN_IFACE_H_
diff --git a/wifi/aidl/default/wifi_rtt_controller.cpp b/wifi/aidl/default/wifi_rtt_controller.cpp
deleted file mode 100644
index 856c3cd..0000000
--- a/wifi/aidl/default/wifi_rtt_controller.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "wifi_rtt_controller.h"
-
-#include <android-base/logging.h>
-
-#include "aidl_return_util.h"
-#include "aidl_struct_util.h"
-#include "wifi_status_util.h"
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-using aidl_return_util::validateAndCall;
-
-WifiRttController::WifiRttController(const std::string& iface_name,
-                                     const std::shared_ptr<IWifiStaIface>& bound_iface,
-                                     const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
-    : ifname_(iface_name), bound_iface_(bound_iface), legacy_hal_(legacy_hal), is_valid_(true) {}
-
-std::shared_ptr<WifiRttController> WifiRttController::create(
-        const std::string& iface_name, const std::shared_ptr<IWifiStaIface>& bound_iface,
-        const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal) {
-    std::shared_ptr<WifiRttController> ptr =
-            ndk::SharedRefBase::make<WifiRttController>(iface_name, bound_iface, legacy_hal);
-    std::weak_ptr<WifiRttController> weak_ptr_this(ptr);
-    ptr->setWeakPtr(weak_ptr_this);
-    return ptr;
-}
-
-void WifiRttController::invalidate() {
-    legacy_hal_.reset();
-    event_callbacks_.clear();
-    is_valid_ = false;
-};
-
-bool WifiRttController::isValid() {
-    return is_valid_;
-}
-
-void WifiRttController::setWeakPtr(std::weak_ptr<WifiRttController> ptr) {
-    weak_ptr_this_ = ptr;
-}
-
-std::vector<std::shared_ptr<IWifiRttControllerEventCallback>>
-WifiRttController::getEventCallbacks() {
-    return event_callbacks_;
-}
-
-std::string WifiRttController::getIfaceName() {
-    return ifname_;
-}
-
-ndk::ScopedAStatus WifiRttController::getBoundIface(std::shared_ptr<IWifiStaIface>* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
-                           &WifiRttController::getBoundIfaceInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiRttController::registerEventCallback(
-        const std::shared_ptr<IWifiRttControllerEventCallback>& callback) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
-                           &WifiRttController::registerEventCallbackInternal, callback);
-}
-
-ndk::ScopedAStatus WifiRttController::rangeRequest(int32_t in_cmdId,
-                                                   const std::vector<RttConfig>& in_rttConfigs) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
-                           &WifiRttController::rangeRequestInternal, in_cmdId, in_rttConfigs);
-}
-
-ndk::ScopedAStatus WifiRttController::rangeCancel(int32_t in_cmdId,
-                                                  const std::vector<MacAddress>& in_addrs) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
-                           &WifiRttController::rangeCancelInternal, in_cmdId, in_addrs);
-}
-
-ndk::ScopedAStatus WifiRttController::getCapabilities(RttCapabilities* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
-                           &WifiRttController::getCapabilitiesInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiRttController::setLci(int32_t in_cmdId, const RttLciInformation& in_lci) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
-                           &WifiRttController::setLciInternal, in_cmdId, in_lci);
-}
-
-ndk::ScopedAStatus WifiRttController::setLcr(int32_t in_cmdId, const RttLcrInformation& in_lcr) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
-                           &WifiRttController::setLcrInternal, in_cmdId, in_lcr);
-}
-
-ndk::ScopedAStatus WifiRttController::getResponderInfo(RttResponder* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
-                           &WifiRttController::getResponderInfoInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiRttController::enableResponder(int32_t in_cmdId,
-                                                      const WifiChannelInfo& in_channelHint,
-                                                      int32_t in_maxDurationInSeconds,
-                                                      const RttResponder& in_info) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
-                           &WifiRttController::enableResponderInternal, in_cmdId, in_channelHint,
-                           in_maxDurationInSeconds, in_info);
-}
-
-ndk::ScopedAStatus WifiRttController::disableResponder(int32_t in_cmdId) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
-                           &WifiRttController::disableResponderInternal, in_cmdId);
-}
-
-std::pair<std::shared_ptr<IWifiStaIface>, ndk::ScopedAStatus>
-WifiRttController::getBoundIfaceInternal() {
-    return {bound_iface_, ndk::ScopedAStatus::ok()};
-}
-
-ndk::ScopedAStatus WifiRttController::registerEventCallbackInternal(
-        const std::shared_ptr<IWifiRttControllerEventCallback>& callback) {
-    event_callbacks_.emplace_back(callback);
-    return ndk::ScopedAStatus::ok();
-}
-
-ndk::ScopedAStatus WifiRttController::rangeRequestInternal(
-        int32_t cmd_id, const std::vector<RttConfig>& rtt_configs) {
-    std::vector<legacy_hal::wifi_rtt_config> legacy_configs;
-    if (!aidl_struct_util::convertAidlVectorOfRttConfigToLegacy(rtt_configs, &legacy_configs)) {
-        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
-    }
-    std::weak_ptr<WifiRttController> weak_ptr_this = weak_ptr_this_;
-    const auto& on_results_callback =
-            [weak_ptr_this](legacy_hal::wifi_request_id id,
-                            const std::vector<const legacy_hal::wifi_rtt_result*>& results) {
-                const auto shared_ptr_this = weak_ptr_this.lock();
-                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-                    LOG(ERROR) << "Callback invoked on an invalid object";
-                    return;
-                }
-                std::vector<RttResult> aidl_results;
-                if (!aidl_struct_util::convertLegacyVectorOfRttResultToAidl(results,
-                                                                            &aidl_results)) {
-                    LOG(ERROR) << "Failed to convert rtt results to AIDL structs";
-                    return;
-                }
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->onResults(id, aidl_results).isOk()) {
-                        LOG(ERROR) << "Failed to invoke the callback";
-                    }
-                }
-            };
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startRttRangeRequest(
-            ifname_, cmd_id, legacy_configs, on_results_callback);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiRttController::rangeCancelInternal(int32_t cmd_id,
-                                                          const std::vector<MacAddress>& addrs) {
-    std::vector<std::array<uint8_t, ETH_ALEN>> legacy_addrs;
-    for (const auto& addr : addrs) {
-        std::array<uint8_t, ETH_ALEN> addr_array;
-        std::copy_n(addr.data.begin(), ETH_ALEN, addr_array.begin());
-        legacy_addrs.push_back(addr_array);
-    }
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->cancelRttRangeRequest(ifname_, cmd_id, legacy_addrs);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-std::pair<RttCapabilities, ndk::ScopedAStatus> WifiRttController::getCapabilitiesInternal() {
-    legacy_hal::wifi_error legacy_status;
-    legacy_hal::wifi_rtt_capabilities legacy_caps;
-    std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getRttCapabilities(ifname_);
-    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
-        return {RttCapabilities{}, createWifiStatusFromLegacyError(legacy_status)};
-    }
-    RttCapabilities aidl_caps;
-    if (!aidl_struct_util::convertLegacyRttCapabilitiesToAidl(legacy_caps, &aidl_caps)) {
-        return {RttCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
-    }
-    return {aidl_caps, ndk::ScopedAStatus::ok()};
-}
-
-ndk::ScopedAStatus WifiRttController::setLciInternal(int32_t cmd_id, const RttLciInformation& lci) {
-    legacy_hal::wifi_lci_information legacy_lci;
-    if (!aidl_struct_util::convertAidlRttLciInformationToLegacy(lci, &legacy_lci)) {
-        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
-    }
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->setRttLci(ifname_, cmd_id, legacy_lci);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiRttController::setLcrInternal(int32_t cmd_id, const RttLcrInformation& lcr) {
-    legacy_hal::wifi_lcr_information legacy_lcr;
-    if (!aidl_struct_util::convertAidlRttLcrInformationToLegacy(lcr, &legacy_lcr)) {
-        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
-    }
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->setRttLcr(ifname_, cmd_id, legacy_lcr);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-std::pair<RttResponder, ndk::ScopedAStatus> WifiRttController::getResponderInfoInternal() {
-    legacy_hal::wifi_error legacy_status;
-    legacy_hal::wifi_rtt_responder legacy_responder;
-    std::tie(legacy_status, legacy_responder) = legacy_hal_.lock()->getRttResponderInfo(ifname_);
-    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
-        return {RttResponder{}, createWifiStatusFromLegacyError(legacy_status)};
-    }
-    RttResponder aidl_responder;
-    if (!aidl_struct_util::convertLegacyRttResponderToAidl(legacy_responder, &aidl_responder)) {
-        return {RttResponder{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
-    }
-    return {aidl_responder, ndk::ScopedAStatus::ok()};
-}
-
-ndk::ScopedAStatus WifiRttController::enableResponderInternal(int32_t cmd_id,
-                                                              const WifiChannelInfo& channel_hint,
-                                                              int32_t max_duration_seconds,
-                                                              const RttResponder& info) {
-    legacy_hal::wifi_channel_info legacy_channel_info;
-    if (!aidl_struct_util::convertAidlWifiChannelInfoToLegacy(channel_hint, &legacy_channel_info)) {
-        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
-    }
-    legacy_hal::wifi_rtt_responder legacy_responder;
-    if (!aidl_struct_util::convertAidlRttResponderToLegacy(info, &legacy_responder)) {
-        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
-    }
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableRttResponder(
-            ifname_, cmd_id, legacy_channel_info, max_duration_seconds, legacy_responder);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiRttController::disableResponderInternal(int32_t cmd_id) {
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->disableRttResponder(ifname_, cmd_id);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/wifi_rtt_controller.h b/wifi/aidl/default/wifi_rtt_controller.h
deleted file mode 100644
index db690c3..0000000
--- a/wifi/aidl/default/wifi_rtt_controller.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef WIFI_RTT_CONTROLLER_H_
-#define WIFI_RTT_CONTROLLER_H_
-
-#include <aidl/android/hardware/wifi/BnWifiRttController.h>
-#include <aidl/android/hardware/wifi/IWifiRttControllerEventCallback.h>
-#include <aidl/android/hardware/wifi/IWifiStaIface.h>
-#include <android-base/macros.h>
-
-#include "wifi_legacy_hal.h"
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-
-/**
- * AIDL interface object used to control all RTT operations.
- */
-class WifiRttController : public BnWifiRttController {
-  public:
-    WifiRttController(const std::string& iface_name,
-                      const std::shared_ptr<IWifiStaIface>& bound_iface,
-                      const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
-    // Factory method - use instead of default constructor.
-    static std::shared_ptr<WifiRttController> create(
-            const std::string& iface_name, const std::shared_ptr<IWifiStaIface>& bound_iface,
-            const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
-
-    // Refer to |WifiChip::invalidate()|.
-    void invalidate();
-    bool isValid();
-    std::vector<std::shared_ptr<IWifiRttControllerEventCallback>> getEventCallbacks();
-    std::string getIfaceName();
-
-    // AIDL methods exposed.
-    ndk::ScopedAStatus getBoundIface(std::shared_ptr<IWifiStaIface>* _aidl_return) override;
-    ndk::ScopedAStatus registerEventCallback(
-            const std::shared_ptr<IWifiRttControllerEventCallback>& callback) override;
-    ndk::ScopedAStatus rangeRequest(int32_t in_cmdId,
-                                    const std::vector<RttConfig>& in_rttConfigs) override;
-    ndk::ScopedAStatus rangeCancel(int32_t in_cmdId,
-                                   const std::vector<MacAddress>& in_addrs) override;
-    ndk::ScopedAStatus getCapabilities(RttCapabilities* _aidl_return) override;
-    ndk::ScopedAStatus setLci(int32_t in_cmdId, const RttLciInformation& in_lci) override;
-    ndk::ScopedAStatus setLcr(int32_t in_cmdId, const RttLcrInformation& in_lcr) override;
-    ndk::ScopedAStatus getResponderInfo(RttResponder* _aidl_return) override;
-    ndk::ScopedAStatus enableResponder(int32_t in_cmdId, const WifiChannelInfo& in_channelHint,
-                                       int32_t in_maxDurationInSeconds,
-                                       const RttResponder& in_info) override;
-    ndk::ScopedAStatus disableResponder(int32_t in_cmdId) override;
-
-  private:
-    // Corresponding worker functions for the AIDL methods.
-    std::pair<std::shared_ptr<IWifiStaIface>, ndk::ScopedAStatus> getBoundIfaceInternal();
-    ndk::ScopedAStatus registerEventCallbackInternal(
-            const std::shared_ptr<IWifiRttControllerEventCallback>& callback);
-    ndk::ScopedAStatus rangeRequestInternal(int32_t cmd_id,
-                                            const std::vector<RttConfig>& rtt_configs);
-    ndk::ScopedAStatus rangeCancelInternal(int32_t cmd_id, const std::vector<MacAddress>& addrs);
-    std::pair<RttCapabilities, ndk::ScopedAStatus> getCapabilitiesInternal();
-    ndk::ScopedAStatus setLciInternal(int32_t cmd_id, const RttLciInformation& lci);
-    ndk::ScopedAStatus setLcrInternal(int32_t cmd_id, const RttLcrInformation& lcr);
-    std::pair<RttResponder, ndk::ScopedAStatus> getResponderInfoInternal();
-    ndk::ScopedAStatus enableResponderInternal(int32_t cmd_id, const WifiChannelInfo& channel_hint,
-                                               int32_t max_duration_seconds,
-                                               const RttResponder& info);
-    ndk::ScopedAStatus disableResponderInternal(int32_t cmd_id);
-
-    void setWeakPtr(std::weak_ptr<WifiRttController> ptr);
-
-    std::string ifname_;
-    std::shared_ptr<IWifiStaIface> bound_iface_;
-    std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
-    std::vector<std::shared_ptr<IWifiRttControllerEventCallback>> event_callbacks_;
-    std::weak_ptr<WifiRttController> weak_ptr_this_;
-    bool is_valid_;
-
-    DISALLOW_COPY_AND_ASSIGN(WifiRttController);
-};
-
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
-
-#endif  // WIFI_RTT_CONTROLLER_H_
diff --git a/wifi/aidl/default/wifi_sta_iface.cpp b/wifi/aidl/default/wifi_sta_iface.cpp
deleted file mode 100644
index ce90349..0000000
--- a/wifi/aidl/default/wifi_sta_iface.cpp
+++ /dev/null
@@ -1,558 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "wifi_sta_iface.h"
-
-#include <android-base/logging.h>
-
-#include "aidl_return_util.h"
-#include "aidl_struct_util.h"
-#include "wifi_status_util.h"
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-using aidl_return_util::validateAndCall;
-
-WifiStaIface::WifiStaIface(const std::string& ifname,
-                           const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-                           const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
-    : ifname_(ifname), legacy_hal_(legacy_hal), iface_util_(iface_util), is_valid_(true) {
-    // Turn on DFS channel usage for STA iface.
-    legacy_hal::wifi_error legacy_status = 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.";
-    }
-}
-
-std::shared_ptr<WifiStaIface> WifiStaIface::create(
-        const std::string& ifname, const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-        const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util) {
-    std::shared_ptr<WifiStaIface> ptr =
-            ndk::SharedRefBase::make<WifiStaIface>(ifname, legacy_hal, iface_util);
-    std::weak_ptr<WifiStaIface> weak_ptr_this(ptr);
-    ptr->setWeakPtr(weak_ptr_this);
-    return ptr;
-}
-
-void WifiStaIface::invalidate() {
-    legacy_hal_.reset();
-    event_cb_handler_.invalidate();
-    is_valid_ = false;
-}
-
-void WifiStaIface::setWeakPtr(std::weak_ptr<WifiStaIface> ptr) {
-    weak_ptr_this_ = ptr;
-}
-
-bool WifiStaIface::isValid() {
-    return is_valid_;
-}
-
-std::string WifiStaIface::getName() {
-    return ifname_;
-}
-
-std::set<std::shared_ptr<IWifiStaIfaceEventCallback>> WifiStaIface::getEventCallbacks() {
-    return event_cb_handler_.getCallbacks();
-}
-
-ndk::ScopedAStatus WifiStaIface::getName(std::string* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::getNameInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiStaIface::registerEventCallback(
-        const std::shared_ptr<IWifiStaIfaceEventCallback>& in_callback) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::registerEventCallbackInternal, in_callback);
-}
-
-ndk::ScopedAStatus WifiStaIface::getCapabilities(
-        IWifiStaIface::StaIfaceCapabilityMask* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::getCapabilitiesInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiStaIface::getApfPacketFilterCapabilities(
-        StaApfPacketFilterCapabilities* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::getApfPacketFilterCapabilitiesInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiStaIface::installApfPacketFilter(const std::vector<uint8_t>& in_program) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::installApfPacketFilterInternal, in_program);
-}
-
-ndk::ScopedAStatus WifiStaIface::readApfPacketFilterData(std::vector<uint8_t>* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::readApfPacketFilterDataInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiStaIface::getBackgroundScanCapabilities(
-        StaBackgroundScanCapabilities* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::getBackgroundScanCapabilitiesInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiStaIface::getValidFrequenciesForBand(WifiBand in_band,
-                                                            std::vector<int32_t>* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::getValidFrequenciesForBandInternal, _aidl_return,
-                           in_band);
-}
-
-ndk::ScopedAStatus WifiStaIface::startBackgroundScan(int32_t in_cmdId,
-                                                     const StaBackgroundScanParameters& in_params) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::startBackgroundScanInternal, in_cmdId, in_params);
-}
-
-ndk::ScopedAStatus WifiStaIface::stopBackgroundScan(int32_t in_cmdId) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::stopBackgroundScanInternal, in_cmdId);
-}
-
-ndk::ScopedAStatus WifiStaIface::enableLinkLayerStatsCollection(bool in_debug) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::enableLinkLayerStatsCollectionInternal, in_debug);
-}
-
-ndk::ScopedAStatus WifiStaIface::disableLinkLayerStatsCollection() {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::disableLinkLayerStatsCollectionInternal);
-}
-
-ndk::ScopedAStatus WifiStaIface::getLinkLayerStats(StaLinkLayerStats* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::getLinkLayerStatsInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiStaIface::startRssiMonitoring(int32_t in_cmdId, int32_t in_maxRssi,
-                                                     int32_t in_minRssi) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::startRssiMonitoringInternal, in_cmdId, in_maxRssi,
-                           in_minRssi);
-}
-
-ndk::ScopedAStatus WifiStaIface::stopRssiMonitoring(int32_t in_cmdId) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::stopRssiMonitoringInternal, in_cmdId);
-}
-
-ndk::ScopedAStatus WifiStaIface::getRoamingCapabilities(StaRoamingCapabilities* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::getRoamingCapabilitiesInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiStaIface::configureRoaming(const StaRoamingConfig& in_config) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::configureRoamingInternal, in_config);
-}
-
-ndk::ScopedAStatus WifiStaIface::setRoamingState(StaRoamingState in_state) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::setRoamingStateInternal, in_state);
-}
-
-ndk::ScopedAStatus WifiStaIface::enableNdOffload(bool in_enable) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::enableNdOffloadInternal, in_enable);
-}
-
-ndk::ScopedAStatus WifiStaIface::startSendingKeepAlivePackets(
-        int32_t in_cmdId, const std::vector<uint8_t>& in_ipPacketData, char16_t in_etherType,
-        const std::array<uint8_t, 6>& in_srcAddress, const std::array<uint8_t, 6>& in_dstAddress,
-        int32_t in_periodInMs) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::startSendingKeepAlivePacketsInternal, in_cmdId,
-                           in_ipPacketData, in_etherType, in_srcAddress, in_dstAddress,
-                           in_periodInMs);
-}
-
-ndk::ScopedAStatus WifiStaIface::stopSendingKeepAlivePackets(int32_t in_cmdId) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::stopSendingKeepAlivePacketsInternal, in_cmdId);
-}
-
-ndk::ScopedAStatus WifiStaIface::startDebugPacketFateMonitoring() {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::startDebugPacketFateMonitoringInternal);
-}
-
-ndk::ScopedAStatus WifiStaIface::getDebugTxPacketFates(
-        std::vector<WifiDebugTxPacketFateReport>* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::getDebugTxPacketFatesInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiStaIface::getDebugRxPacketFates(
-        std::vector<WifiDebugRxPacketFateReport>* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::getDebugRxPacketFatesInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiStaIface::setMacAddress(const std::array<uint8_t, 6>& in_mac) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::setMacAddressInternal, in_mac);
-}
-
-ndk::ScopedAStatus WifiStaIface::getFactoryMacAddress(std::array<uint8_t, 6>* _aidl_return) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::getFactoryMacAddressInternal, _aidl_return);
-}
-
-ndk::ScopedAStatus WifiStaIface::setScanMode(bool in_enable) {
-    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::setScanModeInternal, in_enable);
-}
-
-std::pair<std::string, ndk::ScopedAStatus> WifiStaIface::getNameInternal() {
-    return {ifname_, ndk::ScopedAStatus::ok()};
-}
-
-ndk::ScopedAStatus WifiStaIface::registerEventCallbackInternal(
-        const std::shared_ptr<IWifiStaIfaceEventCallback>& callback) {
-    if (!event_cb_handler_.addCallback(callback)) {
-        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
-    }
-    return ndk::ScopedAStatus::ok();
-}
-
-std::pair<IWifiStaIface::StaIfaceCapabilityMask, ndk::ScopedAStatus>
-WifiStaIface::getCapabilitiesInternal() {
-    legacy_hal::wifi_error legacy_status;
-    uint64_t legacy_feature_set;
-    std::tie(legacy_status, legacy_feature_set) =
-            legacy_hal_.lock()->getSupportedFeatureSet(ifname_);
-    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
-        return {IWifiStaIface::StaIfaceCapabilityMask{},
-                createWifiStatusFromLegacyError(legacy_status)};
-    }
-    uint32_t legacy_logger_feature_set;
-    std::tie(legacy_status, legacy_logger_feature_set) =
-            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;
-    }
-    uint32_t aidl_caps;
-    if (!aidl_struct_util::convertLegacyFeaturesToAidlStaCapabilities(
-                legacy_feature_set, legacy_logger_feature_set, &aidl_caps)) {
-        return {IWifiStaIface::StaIfaceCapabilityMask{},
-                createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
-    }
-    return {static_cast<IWifiStaIface::StaIfaceCapabilityMask>(aidl_caps),
-            ndk::ScopedAStatus::ok()};
-}
-
-std::pair<StaApfPacketFilterCapabilities, ndk::ScopedAStatus>
-WifiStaIface::getApfPacketFilterCapabilitiesInternal() {
-    legacy_hal::wifi_error legacy_status;
-    legacy_hal::PacketFilterCapabilities legacy_caps;
-    std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getPacketFilterCapabilities(ifname_);
-    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
-        return {StaApfPacketFilterCapabilities{}, createWifiStatusFromLegacyError(legacy_status)};
-    }
-    StaApfPacketFilterCapabilities aidl_caps;
-    if (!aidl_struct_util::convertLegacyApfCapabilitiesToAidl(legacy_caps, &aidl_caps)) {
-        return {StaApfPacketFilterCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
-    }
-    return {aidl_caps, ndk::ScopedAStatus::ok()};
-}
-
-ndk::ScopedAStatus WifiStaIface::installApfPacketFilterInternal(
-        const std::vector<uint8_t>& program) {
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setPacketFilter(ifname_, program);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-std::pair<std::vector<uint8_t>, ndk::ScopedAStatus>
-WifiStaIface::readApfPacketFilterDataInternal() {
-    const std::pair<legacy_hal::wifi_error, std::vector<uint8_t>> legacy_status_and_data =
-            legacy_hal_.lock()->readApfPacketFilterData(ifname_);
-    return {std::move(legacy_status_and_data.second),
-            createWifiStatusFromLegacyError(legacy_status_and_data.first)};
-}
-
-std::pair<StaBackgroundScanCapabilities, ndk::ScopedAStatus>
-WifiStaIface::getBackgroundScanCapabilitiesInternal() {
-    legacy_hal::wifi_error legacy_status;
-    legacy_hal::wifi_gscan_capabilities legacy_caps;
-    std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getGscanCapabilities(ifname_);
-    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
-        return {StaBackgroundScanCapabilities{}, createWifiStatusFromLegacyError(legacy_status)};
-    }
-    StaBackgroundScanCapabilities aidl_caps;
-    if (!aidl_struct_util::convertLegacyGscanCapabilitiesToAidl(legacy_caps, &aidl_caps)) {
-        return {StaBackgroundScanCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
-    }
-    return {aidl_caps, ndk::ScopedAStatus::ok()};
-}
-
-std::pair<std::vector<int32_t>, ndk::ScopedAStatus>
-WifiStaIface::getValidFrequenciesForBandInternal(WifiBand band) {
-    static_assert(sizeof(WifiChannelWidthInMhz) == sizeof(int32_t), "Size mismatch");
-    legacy_hal::wifi_error legacy_status;
-    std::vector<uint32_t> valid_frequencies;
-    std::tie(legacy_status, valid_frequencies) = legacy_hal_.lock()->getValidFrequenciesForBand(
-            ifname_, aidl_struct_util::convertAidlWifiBandToLegacy(band));
-    return {std::vector<int32_t>(valid_frequencies.begin(), valid_frequencies.end()),
-            createWifiStatusFromLegacyError(legacy_status)};
-}
-
-ndk::ScopedAStatus WifiStaIface::startBackgroundScanInternal(
-        int32_t cmd_id, const StaBackgroundScanParameters& params) {
-    legacy_hal::wifi_scan_cmd_params legacy_params;
-    if (!aidl_struct_util::convertAidlGscanParamsToLegacy(params, &legacy_params)) {
-        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
-    }
-    std::weak_ptr<WifiStaIface> weak_ptr_this = weak_ptr_this_;
-    const auto& on_failure_callback = [weak_ptr_this](legacy_hal::wifi_request_id id) {
-        const auto shared_ptr_this = weak_ptr_this.lock();
-        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-            LOG(ERROR) << "Callback invoked on an invalid object";
-            return;
-        }
-        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-            if (!callback->onBackgroundScanFailure(id).isOk()) {
-                LOG(ERROR) << "Failed to invoke onBackgroundScanFailure callback";
-            }
-        }
-    };
-    const auto& on_results_callback =
-            [weak_ptr_this](legacy_hal::wifi_request_id id,
-                            const std::vector<legacy_hal::wifi_cached_scan_results>& results) {
-                const auto shared_ptr_this = weak_ptr_this.lock();
-                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-                    LOG(ERROR) << "Callback invoked on an invalid object";
-                    return;
-                }
-                std::vector<StaScanData> aidl_scan_datas;
-                if (!aidl_struct_util::convertLegacyVectorOfCachedGscanResultsToAidl(
-                            results, &aidl_scan_datas)) {
-                    LOG(ERROR) << "Failed to convert scan results to AIDL structs";
-                    return;
-                }
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->onBackgroundScanResults(id, aidl_scan_datas).isOk()) {
-                        LOG(ERROR) << "Failed to invoke onBackgroundScanResults callback";
-                    }
-                }
-            };
-    const auto& on_full_result_callback = [weak_ptr_this](
-                                                  legacy_hal::wifi_request_id id,
-                                                  const legacy_hal::wifi_scan_result* result,
-                                                  uint32_t buckets_scanned) {
-        const auto shared_ptr_this = weak_ptr_this.lock();
-        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-            LOG(ERROR) << "Callback invoked on an invalid object";
-            return;
-        }
-        StaScanResult aidl_scan_result;
-        if (!aidl_struct_util::convertLegacyGscanResultToAidl(*result, true, &aidl_scan_result)) {
-            LOG(ERROR) << "Failed to convert full scan results to AIDL structs";
-            return;
-        }
-        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-            if (!callback->onBackgroundFullScanResult(id, buckets_scanned, aidl_scan_result)
-                         .isOk()) {
-                LOG(ERROR) << "Failed to invoke onBackgroundFullScanResult callback";
-            }
-        }
-    };
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->startGscan(ifname_, cmd_id, legacy_params, on_failure_callback,
-                                           on_results_callback, on_full_result_callback);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiStaIface::stopBackgroundScanInternal(int32_t cmd_id) {
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->stopGscan(ifname_, cmd_id);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiStaIface::enableLinkLayerStatsCollectionInternal(bool debug) {
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableLinkLayerStats(ifname_, debug);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiStaIface::disableLinkLayerStatsCollectionInternal() {
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->disableLinkLayerStats(ifname_);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-std::pair<StaLinkLayerStats, ndk::ScopedAStatus> WifiStaIface::getLinkLayerStatsInternal() {
-    legacy_hal::wifi_error legacy_status;
-    legacy_hal::LinkLayerStats legacy_stats;
-    std::tie(legacy_status, legacy_stats) = legacy_hal_.lock()->getLinkLayerStats(ifname_);
-    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
-        return {StaLinkLayerStats{}, createWifiStatusFromLegacyError(legacy_status)};
-    }
-    StaLinkLayerStats aidl_stats;
-    if (!aidl_struct_util::convertLegacyLinkLayerStatsToAidl(legacy_stats, &aidl_stats)) {
-        return {StaLinkLayerStats{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
-    }
-    return {aidl_stats, ndk::ScopedAStatus::ok()};
-}
-
-ndk::ScopedAStatus WifiStaIface::startRssiMonitoringInternal(int32_t cmd_id, int32_t max_rssi,
-                                                             int32_t min_rssi) {
-    std::weak_ptr<WifiStaIface> weak_ptr_this = weak_ptr_this_;
-    const auto& on_threshold_breached_callback =
-            [weak_ptr_this](legacy_hal::wifi_request_id id, std::array<uint8_t, ETH_ALEN> bssid,
-                            int8_t rssi) {
-                const auto shared_ptr_this = weak_ptr_this.lock();
-                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
-                    LOG(ERROR) << "Callback invoked on an invalid object";
-                    return;
-                }
-                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
-                    if (!callback->onRssiThresholdBreached(id, bssid, rssi).isOk()) {
-                        LOG(ERROR) << "Failed to invoke onRssiThresholdBreached callback";
-                    }
-                }
-            };
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startRssiMonitoring(
-            ifname_, cmd_id, max_rssi, min_rssi, on_threshold_breached_callback);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiStaIface::stopRssiMonitoringInternal(int32_t cmd_id) {
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->stopRssiMonitoring(ifname_, cmd_id);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-std::pair<StaRoamingCapabilities, ndk::ScopedAStatus>
-WifiStaIface::getRoamingCapabilitiesInternal() {
-    legacy_hal::wifi_error legacy_status;
-    legacy_hal::wifi_roaming_capabilities legacy_caps;
-    std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getRoamingCapabilities(ifname_);
-    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
-        return {StaRoamingCapabilities{}, createWifiStatusFromLegacyError(legacy_status)};
-    }
-    StaRoamingCapabilities aidl_caps;
-    if (!aidl_struct_util::convertLegacyRoamingCapabilitiesToAidl(legacy_caps, &aidl_caps)) {
-        return {StaRoamingCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
-    }
-    return {aidl_caps, ndk::ScopedAStatus::ok()};
-}
-
-ndk::ScopedAStatus WifiStaIface::configureRoamingInternal(const StaRoamingConfig& config) {
-    legacy_hal::wifi_roaming_config legacy_config;
-    if (!aidl_struct_util::convertAidlRoamingConfigToLegacy(config, &legacy_config)) {
-        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
-    }
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->configureRoaming(ifname_, legacy_config);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiStaIface::setRoamingStateInternal(StaRoamingState state) {
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableFirmwareRoaming(
-            ifname_, aidl_struct_util::convertAidlRoamingStateToLegacy(state));
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiStaIface::enableNdOffloadInternal(bool enable) {
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->configureNdOffload(ifname_, enable);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiStaIface::startSendingKeepAlivePacketsInternal(
-        int32_t cmd_id, const std::vector<uint8_t>& ip_packet_data, char16_t ether_type,
-        const std::array<uint8_t, 6>& src_address, const std::array<uint8_t, 6>& dst_address,
-        int32_t period_in_ms) {
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startSendingOffloadedPacket(
-            ifname_, cmd_id, ether_type, ip_packet_data, src_address, dst_address, period_in_ms);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiStaIface::stopSendingKeepAlivePacketsInternal(int32_t cmd_id) {
-    legacy_hal::wifi_error legacy_status =
-            legacy_hal_.lock()->stopSendingOffloadedPacket(ifname_, cmd_id);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-ndk::ScopedAStatus WifiStaIface::startDebugPacketFateMonitoringInternal() {
-    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startPktFateMonitoring(ifname_);
-    return createWifiStatusFromLegacyError(legacy_status);
-}
-
-std::pair<std::vector<WifiDebugTxPacketFateReport>, ndk::ScopedAStatus>
-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(ifname_);
-    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
-        return {std::vector<WifiDebugTxPacketFateReport>(),
-                createWifiStatusFromLegacyError(legacy_status)};
-    }
-    std::vector<WifiDebugTxPacketFateReport> aidl_fates;
-    if (!aidl_struct_util::convertLegacyVectorOfDebugTxPacketFateToAidl(legacy_fates,
-                                                                        &aidl_fates)) {
-        return {std::vector<WifiDebugTxPacketFateReport>(),
-                createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
-    }
-    return {aidl_fates, ndk::ScopedAStatus::ok()};
-}
-
-std::pair<std::vector<WifiDebugRxPacketFateReport>, ndk::ScopedAStatus>
-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(ifname_);
-    if (legacy_status != legacy_hal::WIFI_SUCCESS) {
-        return {std::vector<WifiDebugRxPacketFateReport>(),
-                createWifiStatusFromLegacyError(legacy_status)};
-    }
-    std::vector<WifiDebugRxPacketFateReport> aidl_fates;
-    if (!aidl_struct_util::convertLegacyVectorOfDebugRxPacketFateToAidl(legacy_fates,
-                                                                        &aidl_fates)) {
-        return {std::vector<WifiDebugRxPacketFateReport>(),
-                createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
-    }
-    return {aidl_fates, ndk::ScopedAStatus::ok()};
-}
-
-ndk::ScopedAStatus WifiStaIface::setMacAddressInternal(const std::array<uint8_t, 6>& mac) {
-    bool status = iface_util_.lock()->setMacAddress(ifname_, mac);
-    if (!status) {
-        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
-    }
-    return ndk::ScopedAStatus::ok();
-}
-
-std::pair<std::array<uint8_t, 6>, ndk::ScopedAStatus> WifiStaIface::getFactoryMacAddressInternal() {
-    std::array<uint8_t, 6> mac = iface_util_.lock()->getFactoryMacAddress(ifname_);
-    if (mac[0] == 0 && mac[1] == 0 && mac[2] == 0 && mac[3] == 0 && mac[4] == 0 && mac[5] == 0) {
-        return {mac, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
-    }
-    return {mac, ndk::ScopedAStatus::ok()};
-}
-
-ndk::ScopedAStatus WifiStaIface::setScanModeInternal(bool enable) {
-    // OEM's need to implement this on their devices if needed.
-    LOG(WARNING) << "setScanModeInternal(" << enable << ") not supported";
-    return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
-}
-
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
diff --git a/wifi/aidl/default/wifi_sta_iface.h b/wifi/aidl/default/wifi_sta_iface.h
deleted file mode 100644
index 8ac3470..0000000
--- a/wifi/aidl/default/wifi_sta_iface.h
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef WIFI_STA_IFACE_H_
-#define WIFI_STA_IFACE_H_
-
-#include <aidl/android/hardware/wifi/BnWifiStaIface.h>
-#include <aidl/android/hardware/wifi/IWifiStaIfaceEventCallback.h>
-#include <android-base/macros.h>
-
-#include "aidl_callback_util.h"
-#include "wifi_iface_util.h"
-#include "wifi_legacy_hal.h"
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-
-/**
- * AIDL interface object used to control a STA Iface instance.
- */
-class WifiStaIface : public BnWifiStaIface {
-  public:
-    WifiStaIface(const std::string& ifname,
-                 const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-                 const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
-
-    // Factory method - use instead of default constructor.
-    static std::shared_ptr<WifiStaIface> create(
-            const std::string& ifname, const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
-            const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
-
-    // Refer to |WifiChip::invalidate()|.
-    void invalidate();
-    bool isValid();
-    std::set<std::shared_ptr<IWifiStaIfaceEventCallback>> getEventCallbacks();
-    std::string getName();
-
-    // AIDL methods exposed.
-    ndk::ScopedAStatus getName(std::string* _aidl_return) override;
-    ndk::ScopedAStatus registerEventCallback(
-            const std::shared_ptr<IWifiStaIfaceEventCallback>& in_callback) override;
-    ndk::ScopedAStatus getCapabilities(
-            IWifiStaIface::StaIfaceCapabilityMask* _aidl_return) override;
-    ndk::ScopedAStatus getApfPacketFilterCapabilities(
-            StaApfPacketFilterCapabilities* _aidl_return) override;
-    ndk::ScopedAStatus installApfPacketFilter(const std::vector<uint8_t>& in_program) override;
-    ndk::ScopedAStatus readApfPacketFilterData(std::vector<uint8_t>* _aidl_return) override;
-    ndk::ScopedAStatus getBackgroundScanCapabilities(
-            StaBackgroundScanCapabilities* _aidl_return) override;
-    ndk::ScopedAStatus getValidFrequenciesForBand(WifiBand in_band,
-                                                  std::vector<int32_t>* _aidl_return) override;
-    ndk::ScopedAStatus startBackgroundScan(int32_t in_cmdId,
-                                           const StaBackgroundScanParameters& in_params) override;
-    ndk::ScopedAStatus stopBackgroundScan(int32_t in_cmdId) override;
-    ndk::ScopedAStatus enableLinkLayerStatsCollection(bool in_debug) override;
-    ndk::ScopedAStatus disableLinkLayerStatsCollection() override;
-    ndk::ScopedAStatus getLinkLayerStats(StaLinkLayerStats* _aidl_return) override;
-    ndk::ScopedAStatus startRssiMonitoring(int32_t in_cmdId, int32_t in_maxRssi,
-                                           int32_t in_minRssi) override;
-    ndk::ScopedAStatus stopRssiMonitoring(int32_t in_cmdId) override;
-    ndk::ScopedAStatus getRoamingCapabilities(StaRoamingCapabilities* _aidl_return) override;
-    ndk::ScopedAStatus configureRoaming(const StaRoamingConfig& in_config) override;
-    ndk::ScopedAStatus setRoamingState(StaRoamingState in_state) override;
-    ndk::ScopedAStatus enableNdOffload(bool in_enable) override;
-    ndk::ScopedAStatus startSendingKeepAlivePackets(int32_t in_cmdId,
-                                                    const std::vector<uint8_t>& in_ipPacketData,
-                                                    char16_t in_etherType,
-                                                    const std::array<uint8_t, 6>& in_srcAddress,
-                                                    const std::array<uint8_t, 6>& in_dstAddress,
-                                                    int32_t in_periodInMs) override;
-    ndk::ScopedAStatus stopSendingKeepAlivePackets(int32_t in_cmdId) override;
-    ndk::ScopedAStatus startDebugPacketFateMonitoring() override;
-    ndk::ScopedAStatus getDebugTxPacketFates(
-            std::vector<WifiDebugTxPacketFateReport>* _aidl_return) override;
-    ndk::ScopedAStatus getDebugRxPacketFates(
-            std::vector<WifiDebugRxPacketFateReport>* _aidl_return) override;
-    ndk::ScopedAStatus setMacAddress(const std::array<uint8_t, 6>& in_mac) override;
-    ndk::ScopedAStatus getFactoryMacAddress(std::array<uint8_t, 6>* _aidl_return) override;
-    ndk::ScopedAStatus setScanMode(bool in_enable) override;
-
-  private:
-    // Corresponding worker functions for the AIDL methods.
-    std::pair<std::string, ndk::ScopedAStatus> getNameInternal();
-    ndk::ScopedAStatus registerEventCallbackInternal(
-            const std::shared_ptr<IWifiStaIfaceEventCallback>& callback);
-    std::pair<IWifiStaIface::StaIfaceCapabilityMask, ndk::ScopedAStatus> getCapabilitiesInternal();
-    std::pair<StaApfPacketFilterCapabilities, ndk::ScopedAStatus>
-    getApfPacketFilterCapabilitiesInternal();
-    ndk::ScopedAStatus installApfPacketFilterInternal(const std::vector<uint8_t>& program);
-    std::pair<std::vector<uint8_t>, ndk::ScopedAStatus> readApfPacketFilterDataInternal();
-    std::pair<StaBackgroundScanCapabilities, ndk::ScopedAStatus>
-    getBackgroundScanCapabilitiesInternal();
-    std::pair<std::vector<int32_t>, ndk::ScopedAStatus> getValidFrequenciesForBandInternal(
-            WifiBand band);
-    ndk::ScopedAStatus startBackgroundScanInternal(int32_t cmd_id,
-                                                   const StaBackgroundScanParameters& params);
-    ndk::ScopedAStatus stopBackgroundScanInternal(int32_t cmd_id);
-    ndk::ScopedAStatus enableLinkLayerStatsCollectionInternal(bool debug);
-    ndk::ScopedAStatus disableLinkLayerStatsCollectionInternal();
-    std::pair<StaLinkLayerStats, ndk::ScopedAStatus> getLinkLayerStatsInternal();
-    ndk::ScopedAStatus startRssiMonitoringInternal(int32_t cmd_id, int32_t max_rssi,
-                                                   int32_t min_rssi);
-    ndk::ScopedAStatus stopRssiMonitoringInternal(int32_t cmd_id);
-    std::pair<StaRoamingCapabilities, ndk::ScopedAStatus> getRoamingCapabilitiesInternal();
-    ndk::ScopedAStatus configureRoamingInternal(const StaRoamingConfig& config);
-    ndk::ScopedAStatus setRoamingStateInternal(StaRoamingState state);
-    ndk::ScopedAStatus enableNdOffloadInternal(bool enable);
-    ndk::ScopedAStatus startSendingKeepAlivePacketsInternal(
-            int32_t cmd_id, const std::vector<uint8_t>& ip_packet_data, char16_t ether_type,
-            const std::array<uint8_t, 6>& src_address, const std::array<uint8_t, 6>& dst_address,
-            int32_t period_in_ms);
-    ndk::ScopedAStatus stopSendingKeepAlivePacketsInternal(int32_t cmd_id);
-    ndk::ScopedAStatus startDebugPacketFateMonitoringInternal();
-    std::pair<std::vector<WifiDebugTxPacketFateReport>, ndk::ScopedAStatus>
-    getDebugTxPacketFatesInternal();
-    std::pair<std::vector<WifiDebugRxPacketFateReport>, ndk::ScopedAStatus>
-    getDebugRxPacketFatesInternal();
-    ndk::ScopedAStatus setMacAddressInternal(const std::array<uint8_t, 6>& mac);
-    std::pair<std::array<uint8_t, 6>, ndk::ScopedAStatus> getFactoryMacAddressInternal();
-    ndk::ScopedAStatus setScanModeInternal(bool enable);
-
-    void setWeakPtr(std::weak_ptr<WifiStaIface> ptr);
-
-    std::string ifname_;
-    std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
-    std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
-    std::weak_ptr<WifiStaIface> weak_ptr_this_;
-    bool is_valid_;
-    aidl_callback_util::AidlCallbackHandler<IWifiStaIfaceEventCallback> event_cb_handler_;
-
-    DISALLOW_COPY_AND_ASSIGN(WifiStaIface);
-};
-
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
-
-#endif  // WIFI_STA_IFACE_H_
diff --git a/wifi/aidl/default/wifi_status_util.h b/wifi/aidl/default/wifi_status_util.h
deleted file mode 100644
index 633811d..0000000
--- a/wifi/aidl/default/wifi_status_util.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef WIFI_STATUS_UTIL_H_
-#define WIFI_STATUS_UTIL_H_
-
-#include <aidl/android/hardware/wifi/IWifi.h>
-
-#include "wifi_legacy_hal.h"
-
-namespace aidl {
-namespace android {
-namespace hardware {
-namespace wifi {
-using ::aidl::android::hardware::wifi::WifiStatusCode;
-
-std::string legacyErrorToString(legacy_hal::wifi_error error);
-ndk::ScopedAStatus createWifiStatus(WifiStatusCode code, const std::string& description);
-ndk::ScopedAStatus createWifiStatus(WifiStatusCode code);
-ndk::ScopedAStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error,
-                                                   const std::string& description);
-ndk::ScopedAStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error);
-
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
-}  // namespace aidl
-
-#endif  // WIFI_STATUS_UTIL_H_
diff --git a/wifi/aidl/vts/functional/Android.bp b/wifi/aidl/vts/functional/Android.bp
deleted file mode 100644
index 1277182..0000000
--- a/wifi/aidl/vts/functional/Android.bp
+++ /dev/null
@@ -1,169 +0,0 @@
-//
-// Copyright (C) 2022 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-package {
-    // See: http://go/android-license-faq
-    // A large-scale-change added 'default_applicable_licenses' to import
-    // all of the 'license_kinds' from "hardware_interfaces_license"
-    // to get the below license kinds:
-    //   SPDX-license-identifier-Apache-2.0
-    default_applicable_licenses: ["hardware_interfaces_license"],
-}
-
-cc_test {
-    name: "VtsHalWifiChipTargetTest",
-    defaults: [
-        "VtsHalTargetTestDefaults",
-        "use_libaidlvintf_gtest_helper_static",
-    ],
-    srcs: [
-        "wifi_chip_aidl_test.cpp",
-    ],
-    shared_libs: [
-        "libbinder",
-        "libbinder_ndk",
-        "libvndksupport",
-    ],
-    static_libs: [
-        "VtsHalWifiTargetTestUtil",
-        "android.hardware.wifi-V1-ndk",
-        "libwifi-system-iface",
-    ],
-    test_suites: [
-        "general-tests",
-        "vts",
-    ],
-}
-
-cc_test {
-    name: "VtsHalWifiStaIfaceTargetTest",
-    defaults: [
-        "VtsHalTargetTestDefaults",
-        "use_libaidlvintf_gtest_helper_static",
-    ],
-    srcs: [
-        "wifi_sta_iface_aidl_test.cpp",
-    ],
-    shared_libs: [
-        "libbinder",
-        "libbinder_ndk",
-        "libvndksupport",
-    ],
-    static_libs: [
-        "VtsHalWifiTargetTestUtil",
-        "android.hardware.wifi-V1-ndk",
-        "libwifi-system-iface",
-    ],
-    test_suites: [
-        "general-tests",
-        "vts",
-    ],
-}
-
-cc_test {
-    name: "VtsHalWifiApIfaceTargetTest",
-    defaults: [
-        "VtsHalTargetTestDefaults",
-        "use_libaidlvintf_gtest_helper_static",
-    ],
-    srcs: [
-        "wifi_ap_iface_aidl_test.cpp",
-    ],
-    shared_libs: [
-        "libbinder",
-        "libbinder_ndk",
-        "libvndksupport",
-    ],
-    static_libs: [
-        "VtsHalWifiTargetTestUtil",
-        "android.hardware.wifi-V1-ndk",
-        "libwifi-system-iface",
-    ],
-    test_suites: [
-        "general-tests",
-        "vts",
-    ],
-}
-
-cc_test {
-    name: "VtsHalWifiNanIfaceTargetTest",
-    defaults: [
-        "VtsHalTargetTestDefaults",
-        "use_libaidlvintf_gtest_helper_static",
-    ],
-    srcs: [
-        "wifi_nan_iface_aidl_test.cpp",
-    ],
-    shared_libs: [
-        "libbinder",
-        "libbinder_ndk",
-        "libvndksupport",
-    ],
-    static_libs: [
-        "VtsHalWifiTargetTestUtil",
-        "android.hardware.wifi-V1-ndk",
-        "libwifi-system-iface",
-    ],
-    test_suites: [
-        "general-tests",
-        "vts",
-    ],
-}
-
-cc_test {
-    name: "VtsHalWifiRttControllerTargetTest",
-    defaults: [
-        "VtsHalTargetTestDefaults",
-        "use_libaidlvintf_gtest_helper_static",
-    ],
-    srcs: [
-        "wifi_rtt_controller_aidl_test.cpp",
-    ],
-    shared_libs: [
-        "libbinder",
-        "libbinder_ndk",
-        "libvndksupport",
-    ],
-    static_libs: [
-        "VtsHalWifiTargetTestUtil",
-        "android.hardware.wifi-V1-ndk",
-        "libwifi-system-iface",
-    ],
-    test_suites: [
-        "general-tests",
-        "vts",
-    ],
-}
-
-cc_library_static {
-    name: "VtsHalWifiTargetTestUtil",
-    defaults: ["VtsHalTargetTestDefaults"],
-    srcs: [
-        "wifi_aidl_test_utils.cpp",
-    ],
-    export_include_dirs: [
-        ".",
-    ],
-    shared_libs: [
-        "libbinder",
-        "libbinder_ndk",
-        "libnativehelper",
-    ],
-    static_libs: [
-        "android.hardware.wifi-V1-ndk",
-        "libwifi-system-iface",
-    ],
-}
diff --git a/wifi/aidl/vts/functional/wifi_aidl_test_utils.cpp b/wifi/aidl/vts/functional/wifi_aidl_test_utils.cpp
deleted file mode 100644
index 6722f36..0000000
--- a/wifi/aidl/vts/functional/wifi_aidl_test_utils.cpp
+++ /dev/null
@@ -1,216 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "wifi_aidl_test_utils.h"
-
-using ::android::wifi_system::InterfaceTool;
-
-namespace {
-bool findAnyModeSupportingConcurrencyType(IfaceConcurrencyType desired_type,
-                                          const std::vector<IWifiChip::ChipMode>& modes,
-                                          int* mode_id) {
-    for (const auto& mode : modes) {
-        for (const auto& combination : mode.availableCombinations) {
-            for (const auto& iface_limit : combination.limits) {
-                const auto& iface_types = iface_limit.types;
-                if (std::find(iface_types.begin(), iface_types.end(), desired_type) !=
-                    iface_types.end()) {
-                    *mode_id = mode.id;
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-
-bool configureChipToSupportConcurrencyTypeInternal(const std::shared_ptr<IWifiChip>& wifi_chip,
-                                                   IfaceConcurrencyType type,
-                                                   int* configured_mode_id) {
-    if (!configured_mode_id) {
-        return false;
-    }
-    std::vector<IWifiChip::ChipMode> chip_modes;
-    auto status = wifi_chip->getAvailableModes(&chip_modes);
-    if (!status.isOk()) {
-        return false;
-    }
-    if (!findAnyModeSupportingConcurrencyType(type, chip_modes, configured_mode_id)) {
-        return false;
-    }
-    if (!wifi_chip->configureChip(*configured_mode_id).isOk()) {
-        return false;
-    }
-    return true;
-}
-
-bool configureChipToSupportConcurrencyTypeInternal(const std::shared_ptr<IWifiChip>& wifi_chip,
-                                                   IfaceConcurrencyType type) {
-    int mode_id;
-    return configureChipToSupportConcurrencyTypeInternal(wifi_chip, type, &mode_id);
-}
-}  // namespace
-
-bool checkStatusCode(ndk::ScopedAStatus* status, WifiStatusCode expected_code) {
-    if (status == nullptr) {
-        return false;
-    }
-    return status->getServiceSpecificError() == static_cast<int32_t>(expected_code);
-}
-
-std::shared_ptr<IWifi> getWifi(const char* instance_name) {
-    return IWifi::fromBinder(ndk::SpAIBinder(AServiceManager_waitForService(instance_name)));
-}
-
-std::shared_ptr<IWifiChip> getWifiChip(const char* instance_name) {
-    std::shared_ptr<IWifi> wifi = getWifi(instance_name);
-    if (!wifi.get()) {
-        return nullptr;
-    }
-
-    const int retry_interval_ms = 2;
-    const int max_retries = 5;
-    int retry_count = 0;
-    auto status = wifi->start();
-    while (retry_count < max_retries && !status.isOk()) {
-        retry_count++;
-        usleep(retry_interval_ms * 1000);
-        status = wifi->start();
-    }
-    if (!status.isOk()) {
-        return nullptr;
-    }
-
-    std::vector<int> chip_ids = {};
-    status = wifi->getChipIds(&chip_ids);
-    if (!status.isOk() || chip_ids.size() == 0) {
-        return nullptr;
-    }
-    std::shared_ptr<IWifiChip> chip;
-    status = wifi->getChip(chip_ids[0], &chip);
-    if (!status.isOk()) {
-        return nullptr;
-    }
-    return chip;
-}
-
-void setupStaIface(const std::shared_ptr<IWifiStaIface>& iface) {
-    std::string iface_name;
-    auto status = iface->getName(&iface_name);
-    if (status.isOk()) {
-        InterfaceTool iface_tool;
-        iface_tool.SetUpState(iface_name.c_str(), true);
-    }
-}
-
-void setupNanIface(const std::shared_ptr<IWifiNanIface>& iface) {
-    std::string iface_name;
-    auto status = iface->getName(&iface_name);
-    if (status.isOk()) {
-        InterfaceTool iface_tool;
-        iface_tool.SetUpState(iface_name.c_str(), true);
-    }
-}
-
-std::shared_ptr<IWifiStaIface> getWifiStaIface(const char* instance_name) {
-    std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(instance_name);
-    if (!wifi_chip.get()) {
-        return nullptr;
-    }
-    if (!configureChipToSupportConcurrencyTypeInternal(wifi_chip, IfaceConcurrencyType::STA)) {
-        return nullptr;
-    }
-    std::shared_ptr<IWifiStaIface> iface;
-    auto status = wifi_chip->createStaIface(&iface);
-    if (!status.isOk()) {
-        return nullptr;
-    }
-    setupStaIface(iface);
-    return iface;
-}
-
-std::shared_ptr<IWifiNanIface> getWifiNanIface(const char* instance_name) {
-    std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(instance_name);
-    if (!wifi_chip.get()) {
-        return nullptr;
-    }
-    if (!configureChipToSupportConcurrencyTypeInternal(wifi_chip,
-                                                       IfaceConcurrencyType::NAN_IFACE)) {
-        return nullptr;
-    }
-    std::shared_ptr<IWifiNanIface> iface;
-    auto status = wifi_chip->createNanIface(&iface);
-    if (!status.isOk()) {
-        return nullptr;
-    }
-    setupNanIface(iface);
-    return iface;
-}
-
-std::shared_ptr<IWifiApIface> getWifiApIface(const char* instance_name) {
-    std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(instance_name);
-    if (!wifi_chip.get()) {
-        return nullptr;
-    }
-    if (!configureChipToSupportConcurrencyTypeInternal(wifi_chip, IfaceConcurrencyType::AP)) {
-        return nullptr;
-    }
-    std::shared_ptr<IWifiApIface> iface;
-    auto status = wifi_chip->createApIface(&iface);
-    if (!status.isOk()) {
-        return nullptr;
-    }
-    return iface;
-}
-
-std::shared_ptr<IWifiApIface> getBridgedWifiApIface(std::shared_ptr<IWifiChip> wifi_chip) {
-    if (!wifi_chip.get()) {
-        return nullptr;
-    }
-    int mode_id;
-    std::shared_ptr<IWifiApIface> iface;
-    configureChipToSupportConcurrencyTypeInternal(wifi_chip, IfaceConcurrencyType::AP, &mode_id);
-    auto status = wifi_chip->createBridgedApIface(&iface);
-    if (!status.isOk()) {
-        return nullptr;
-    }
-    return iface;
-}
-
-std::shared_ptr<IWifiApIface> getBridgedWifiApIface(const char* instance_name) {
-    std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(instance_name);
-    return getBridgedWifiApIface(wifi_chip);
-}
-
-bool configureChipToSupportConcurrencyType(const std::shared_ptr<IWifiChip>& wifi_chip,
-                                           IfaceConcurrencyType type, int* configured_mode_id) {
-    return configureChipToSupportConcurrencyTypeInternal(wifi_chip, type, configured_mode_id);
-}
-
-void stopWifiService(const char* instance_name) {
-    std::shared_ptr<IWifi> wifi = getWifi(instance_name);
-    if (wifi != nullptr) {
-        wifi->stop();
-    }
-}
-
-int32_t getChipCapabilities(const std::shared_ptr<IWifiChip>& wifi_chip) {
-    IWifiChip::ChipCapabilityMask caps = {};
-    if (wifi_chip->getCapabilities(&caps).isOk()) {
-        return static_cast<int32_t>(caps);
-    }
-    return 0;
-}
diff --git a/wifi/aidl/vts/functional/wifi_aidl_test_utils.h b/wifi/aidl/vts/functional/wifi_aidl_test_utils.h
deleted file mode 100644
index ad16603..0000000
--- a/wifi/aidl/vts/functional/wifi_aidl_test_utils.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <VtsCoreUtil.h>
-
-#include <aidl/android/hardware/wifi/IWifi.h>
-#include <aidl/android/hardware/wifi/IWifiChip.h>
-#include <android/binder_manager.h>
-#include <wifi_system/interface_tool.h>
-
-using aidl::android::hardware::wifi::IfaceConcurrencyType;
-using aidl::android::hardware::wifi::IWifi;
-using aidl::android::hardware::wifi::IWifiApIface;
-using aidl::android::hardware::wifi::IWifiChip;
-using aidl::android::hardware::wifi::IWifiNanIface;
-using aidl::android::hardware::wifi::IWifiStaIface;
-using aidl::android::hardware::wifi::WifiStatusCode;
-
-// Helper functions to obtain references to the various AIDL interface objects.
-std::shared_ptr<IWifi> getWifi(const char* instance_name);
-std::shared_ptr<IWifiChip> getWifiChip(const char* instance_name);
-std::shared_ptr<IWifiStaIface> getWifiStaIface(const char* instance_name);
-std::shared_ptr<IWifiNanIface> getWifiNanIface(const char* instance_name);
-std::shared_ptr<IWifiApIface> getWifiApIface(const char* instance_name);
-std::shared_ptr<IWifiApIface> getBridgedWifiApIface(const char* instance_name);
-std::shared_ptr<IWifiApIface> getBridgedWifiApIface(std::shared_ptr<IWifiChip> wifi_chip);
-// Configure the chip in a mode to support the creation of the provided iface type.
-bool configureChipToSupportConcurrencyType(const std::shared_ptr<IWifiChip>& wifi_chip,
-                                           IfaceConcurrencyType type, int* configured_mode_id);
-// Used to trigger IWifi.stop() at the end of every test.
-void stopWifiService(const char* instance_name);
-int32_t getChipCapabilities(const std::shared_ptr<IWifiChip>& wifi_chip);
-bool checkStatusCode(ndk::ScopedAStatus* status, WifiStatusCode expected_code);
diff --git a/wifi/aidl/vts/functional/wifi_ap_iface_aidl_test.cpp b/wifi/aidl/vts/functional/wifi_ap_iface_aidl_test.cpp
deleted file mode 100644
index 0eaf660..0000000
--- a/wifi/aidl/vts/functional/wifi_ap_iface_aidl_test.cpp
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Staache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <vector>
-
-#include <VtsCoreUtil.h>
-#include <aidl/Gtest.h>
-#include <aidl/Vintf.h>
-#include <aidl/android/hardware/wifi/BnWifi.h>
-#include <android/binder_manager.h>
-#include <android/binder_status.h>
-#include <binder/IServiceManager.h>
-#include <binder/ProcessState.h>
-
-#include "wifi_aidl_test_utils.h"
-
-using aidl::android::hardware::wifi::IWifiApIface;
-using aidl::android::hardware::wifi::WifiBand;
-
-class WifiApIfaceAidlTest : public testing::TestWithParam<std::string> {
-  public:
-    void SetUp() override {
-        isBridgedSupport_ = testing::checkSubstringInCommandOutput(
-                "/system/bin/cmd wifi get-softap-supported-features",
-                "wifi_softap_bridged_ap_supported");
-        stopWifiService(getInstanceName());
-    }
-
-    void TearDown() override { stopWifiService(getInstanceName()); }
-
-  protected:
-    bool isBridgedSupport_ = false;
-    const char* getInstanceName() { return GetParam().c_str(); }
-};
-
-/*
- * SetMacAddress
- */
-TEST_P(WifiApIfaceAidlTest, SetMacAddress) {
-    std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApIface(getInstanceName());
-    ASSERT_NE(nullptr, wifi_ap_iface.get());
-    std::array<uint8_t, 6> mac = {0x12, 0x22, 0x33, 0x52, 0x10, 0x44};
-    EXPECT_TRUE(wifi_ap_iface->setMacAddress(mac).isOk());
-}
-
-/*
- * SetCountryCode
- */
-TEST_P(WifiApIfaceAidlTest, SetCountryCode) {
-    std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApIface(getInstanceName());
-    ASSERT_NE(nullptr, wifi_ap_iface.get());
-
-    const std::array<uint8_t, 2> country_code = {0x55, 0x53};
-    EXPECT_TRUE(wifi_ap_iface->setCountryCode(country_code).isOk());
-}
-
-/*
- * GetValidFrequenciesForBand
- * Ensures that we can retrieve valid frequencies for the 2.4 GHz band.
- */
-TEST_P(WifiApIfaceAidlTest, GetValidFrequenciesForBand) {
-    std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApIface(getInstanceName());
-    ASSERT_NE(nullptr, wifi_ap_iface.get());
-
-    std::vector<int32_t> freqs;
-    EXPECT_TRUE(wifi_ap_iface->getValidFrequenciesForBand(WifiBand::BAND_24GHZ, &freqs).isOk());
-    EXPECT_NE(freqs.size(), 0);
-}
-
-/*
- * GetFactoryMacAddress
- */
-TEST_P(WifiApIfaceAidlTest, GetFactoryMacAddress) {
-    std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApIface(getInstanceName());
-    ASSERT_NE(nullptr, wifi_ap_iface.get());
-
-    std::array<uint8_t, 6> mac;
-    EXPECT_TRUE(wifi_ap_iface->getFactoryMacAddress(&mac).isOk());
-    std::array<uint8_t, 6> all_zero_mac = {0, 0, 0, 0, 0, 0};
-    EXPECT_NE(mac, all_zero_mac);
-}
-
-/**
- * GetBridgedInstances - non-bridged mode
- */
-TEST_P(WifiApIfaceAidlTest, GetBridgedInstances) {
-    std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApIface(getInstanceName());
-    ASSERT_NE(nullptr, wifi_ap_iface.get());
-
-    std::vector<std::string> instances;
-    EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances).isOk());
-    EXPECT_EQ(instances.size(), 0);
-}
-
-/**
- * GetBridgedInstances - bridged AP mode.
- */
-TEST_P(WifiApIfaceAidlTest, GetBridgedInstances_Bridged) {
-    if (!isBridgedSupport_) {
-        GTEST_SKIP() << "Missing Bridged AP support";
-    }
-    std::shared_ptr<IWifiApIface> wifi_ap_iface = getBridgedWifiApIface(getInstanceName());
-    ASSERT_NE(nullptr, wifi_ap_iface.get());
-
-    std::vector<std::string> instances;
-    EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances).isOk());
-    EXPECT_EQ(instances.size(), 2);
-}
-
-/**
- * ResetToFactoryMacAddress - non-bridged mode
- */
-TEST_P(WifiApIfaceAidlTest, ResetToFactoryMacAddress) {
-    std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApIface(getInstanceName());
-    ASSERT_NE(nullptr, wifi_ap_iface.get());
-    EXPECT_TRUE(wifi_ap_iface->resetToFactoryMacAddress().isOk());
-}
-
-/**
- * ResetToFactoryMacAddress - bridged AP mode
- */
-TEST_P(WifiApIfaceAidlTest, ResetToFactoryMacAddress_Bridged) {
-    if (!isBridgedSupport_) {
-        GTEST_SKIP() << "Missing Bridged AP support";
-    }
-    std::shared_ptr<IWifiApIface> wifi_ap_iface = getBridgedWifiApIface(getInstanceName());
-    ASSERT_NE(nullptr, wifi_ap_iface.get());
-    EXPECT_TRUE(wifi_ap_iface->resetToFactoryMacAddress().isOk());
-}
-
-GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiApIfaceAidlTest);
-INSTANTIATE_TEST_SUITE_P(WifiTest, WifiApIfaceAidlTest,
-                         testing::ValuesIn(android::getAidlHalInstanceNames(IWifi::descriptor)),
-                         android::PrintInstanceNameToString);
-
-int main(int argc, char** argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-    android::ProcessState::self()->setThreadPoolMaxThreadCount(1);
-    android::ProcessState::self()->startThreadPool();
-    return RUN_ALL_TESTS();
-}
diff --git a/wifi/aidl/vts/functional/wifi_chip_aidl_test.cpp b/wifi/aidl/vts/functional/wifi_chip_aidl_test.cpp
deleted file mode 100644
index 0806ed2..0000000
--- a/wifi/aidl/vts/functional/wifi_chip_aidl_test.cpp
+++ /dev/null
@@ -1,889 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Staache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <numeric>
-#include <vector>
-
-#include <VtsCoreUtil.h>
-#include <aidl/Gtest.h>
-#include <aidl/Vintf.h>
-#include <aidl/android/hardware/wifi/BnWifi.h>
-#include <aidl/android/hardware/wifi/BnWifiChipEventCallback.h>
-#include <android/binder_manager.h>
-#include <android/binder_status.h>
-#include <binder/IServiceManager.h>
-#include <binder/ProcessState.h>
-
-#include "wifi_aidl_test_utils.h"
-
-using aidl::android::hardware::wifi::BnWifiChipEventCallback;
-using aidl::android::hardware::wifi::IfaceType;
-using aidl::android::hardware::wifi::IWifiApIface;
-using aidl::android::hardware::wifi::IWifiChip;
-using aidl::android::hardware::wifi::IWifiNanIface;
-using aidl::android::hardware::wifi::IWifiP2pIface;
-using aidl::android::hardware::wifi::IWifiRttController;
-using aidl::android::hardware::wifi::WifiBand;
-using aidl::android::hardware::wifi::WifiDebugHostWakeReasonStats;
-using aidl::android::hardware::wifi::WifiDebugRingBufferStatus;
-using aidl::android::hardware::wifi::WifiDebugRingBufferVerboseLevel;
-using aidl::android::hardware::wifi::WifiIfaceMode;
-using aidl::android::hardware::wifi::WifiRadioCombinationMatrix;
-using aidl::android::hardware::wifi::WifiStatusCode;
-using aidl::android::hardware::wifi::WifiUsableChannel;
-
-class WifiChipAidlTest : public testing::TestWithParam<std::string> {
-  public:
-    void SetUp() override {
-        stopWifiService(getInstanceName());
-        wifi_chip_ = getWifiChip(getInstanceName());
-        ASSERT_NE(nullptr, wifi_chip_.get());
-    }
-
-    void TearDown() override { stopWifiService(getInstanceName()); }
-
-  protected:
-    int configureChipForConcurrencyType(IfaceConcurrencyType type) {
-        int mode_id;
-        EXPECT_TRUE(configureChipToSupportConcurrencyType(wifi_chip_, type, &mode_id));
-        return mode_id;
-    }
-
-    std::shared_ptr<IWifiStaIface> configureChipForStaAndGetIface() {
-        std::shared_ptr<IWifiStaIface> iface;
-        configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-        EXPECT_TRUE(wifi_chip_->createStaIface(&iface).isOk());
-        EXPECT_NE(nullptr, iface.get());
-        return iface;
-    }
-
-    std::shared_ptr<IWifiP2pIface> configureChipForP2pAndGetIface() {
-        std::shared_ptr<IWifiP2pIface> iface;
-        configureChipForConcurrencyType(IfaceConcurrencyType::P2P);
-        EXPECT_TRUE(wifi_chip_->createP2pIface(&iface).isOk());
-        EXPECT_NE(nullptr, iface.get());
-        return iface;
-    }
-
-    std::shared_ptr<IWifiApIface> configureChipForApAndGetIface() {
-        std::shared_ptr<IWifiApIface> iface;
-        configureChipForConcurrencyType(IfaceConcurrencyType::AP);
-        EXPECT_TRUE(wifi_chip_->createApIface(&iface).isOk());
-        EXPECT_NE(nullptr, iface.get());
-        return iface;
-    }
-
-    std::shared_ptr<IWifiNanIface> configureChipForNanAndGetIface() {
-        std::shared_ptr<IWifiNanIface> iface;
-        configureChipForConcurrencyType(IfaceConcurrencyType::NAN_IFACE);
-        EXPECT_TRUE(wifi_chip_->createNanIface(&iface).isOk());
-        EXPECT_NE(nullptr, iface.get());
-        return iface;
-    }
-
-    std::string getStaIfaceName(const std::shared_ptr<IWifiStaIface>& iface) {
-        std::string iface_name;
-        EXPECT_TRUE(iface->getName(&iface_name).isOk());
-        return iface_name;
-    }
-
-    std::string getP2pIfaceName(const std::shared_ptr<IWifiP2pIface>& iface) {
-        std::string iface_name;
-        EXPECT_TRUE(iface->getName(&iface_name).isOk());
-        return iface_name;
-    }
-
-    std::string getApIfaceName(const std::shared_ptr<IWifiApIface>& iface) {
-        std::string iface_name;
-        EXPECT_TRUE(iface->getName(&iface_name).isOk());
-        return iface_name;
-    }
-
-    std::string getNanIfaceName(const std::shared_ptr<IWifiNanIface>& iface) {
-        std::string iface_name;
-        EXPECT_TRUE(iface->getName(&iface_name).isOk());
-        return iface_name;
-    }
-
-    std::vector<std::shared_ptr<IWifiStaIface>> create2StaIfacesIfPossible() {
-        std::shared_ptr<IWifiStaIface> iface1 = configureChipForStaAndGetIface();
-
-        // Try create a create second iface.
-        std::shared_ptr<IWifiStaIface> iface2;
-        bool add_second_success = wifi_chip_->createStaIface(&iface2).isOk();
-        if (!add_second_success) {
-            return {iface1};
-        }
-        EXPECT_NE(nullptr, iface2.get());
-        return {iface1, iface2};
-    }
-
-    bool hasAnyRingBufferCapabilities(int32_t caps) {
-        return caps &
-               (static_cast<int32_t>(
-                        IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_CONNECT_EVENT) |
-                static_cast<int32_t>(IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_POWER_EVENT) |
-                static_cast<int32_t>(
-                        IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_WAKELOCK_EVENT) |
-                static_cast<int32_t>(IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_VENDOR_DATA));
-    }
-
-    const char* getInstanceName() { return GetParam().c_str(); }
-
-    std::shared_ptr<IWifiChip> wifi_chip_;
-};
-
-class WifiChipEventCallback : public BnWifiChipEventCallback {
-  public:
-    WifiChipEventCallback() = default;
-
-    ::ndk::ScopedAStatus onChipReconfigureFailure(WifiStatusCode /* status */) override {
-        return ndk::ScopedAStatus::ok();
-    }
-    ::ndk::ScopedAStatus onChipReconfigured(int /* modeId */) override {
-        return ndk::ScopedAStatus::ok();
-    }
-    ::ndk::ScopedAStatus onDebugErrorAlert(int /* errorCode */,
-                                           const std::vector<uint8_t>& /* debugData */) override {
-        return ndk::ScopedAStatus::ok();
-    }
-    ::ndk::ScopedAStatus onDebugRingBufferDataAvailable(
-            const WifiDebugRingBufferStatus& /* status */,
-            const std::vector<uint8_t>& /* data */) override {
-        return ndk::ScopedAStatus::ok();
-    }
-    ::ndk::ScopedAStatus onIfaceAdded(IfaceType /* type */,
-                                      const std::string& /* name */) override {
-        return ndk::ScopedAStatus::ok();
-    }
-    ::ndk::ScopedAStatus onIfaceRemoved(IfaceType /* type */,
-                                        const std::string& /* name */) override {
-        return ndk::ScopedAStatus::ok();
-    }
-    ::ndk::ScopedAStatus onRadioModeChange(
-            const std::vector<RadioModeInfo>& /* radioModeInfos */) override {
-        return ndk::ScopedAStatus::ok();
-    }
-};
-
-/*
- * RegisterEventCallback
- *
- * Note: it is not feasible to test the invocation of the callback function,
- * since events are triggered internally in the HAL implementation and cannot be
- * triggered from the test case.
- */
-TEST_P(WifiChipAidlTest, RegisterEventCallback) {
-    std::shared_ptr<WifiChipEventCallback> callback =
-            ndk::SharedRefBase::make<WifiChipEventCallback>();
-    ASSERT_NE(nullptr, callback.get());
-    EXPECT_TRUE(wifi_chip_->registerEventCallback(callback).isOk());
-}
-
-/*
- * GetCapabilities
- */
-TEST_P(WifiChipAidlTest, GetCapabilities) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    int32_t caps = getChipCapabilities(wifi_chip_);
-    EXPECT_NE(static_cast<int32_t>(caps), 0);
-}
-
-/*
- * GetId
- */
-TEST_P(WifiChipAidlTest, GetId) {
-    int id;
-    EXPECT_TRUE(wifi_chip_->getId(&id).isOk());
-}
-
-/*
- * GetAvailableModes
- */
-TEST_P(WifiChipAidlTest, GetAvailableModes) {
-    std::vector<IWifiChip::ChipMode> modes;
-    EXPECT_TRUE(wifi_chip_->getAvailableModes(&modes).isOk());
-    EXPECT_NE(modes.size(), 0);
-}
-
-/*
- * GetMode
- */
-TEST_P(WifiChipAidlTest, GetMode) {
-    int expected_mode = configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    int retrieved_mode;
-    EXPECT_TRUE(wifi_chip_->getMode(&retrieved_mode).isOk());
-    EXPECT_EQ(retrieved_mode, expected_mode);
-}
-
-/*
- * GetUsableChannels
- */
-TEST_P(WifiChipAidlTest, GetUsableChannels) {
-    WifiBand band = WifiBand::BAND_24GHZ_5GHZ_6GHZ;
-    uint32_t ifaceModeMask = static_cast<uint32_t>(WifiIfaceMode::IFACE_MODE_P2P_CLIENT) |
-                             static_cast<uint32_t>(WifiIfaceMode::IFACE_MODE_P2P_GO);
-    uint32_t filterMask =
-            static_cast<uint32_t>(IWifiChip::UsableChannelFilter::CELLULAR_COEXISTENCE) |
-            static_cast<uint32_t>(IWifiChip::UsableChannelFilter::CONCURRENCY);
-
-    std::vector<WifiUsableChannel> channels;
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    auto status = wifi_chip_->getUsableChannels(
-            band, static_cast<WifiIfaceMode>(ifaceModeMask),
-            static_cast<IWifiChip::UsableChannelFilter>(filterMask), &channels);
-    if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
-        GTEST_SKIP() << "getUsableChannels() is not supported by vendor.";
-    }
-    EXPECT_TRUE(status.isOk());
-}
-
-/*
- * GetSupportedRadioCombinationsMatrix
- */
-TEST_P(WifiChipAidlTest, GetSupportedRadioCombinationsMatrix) {
-    WifiRadioCombinationMatrix combination_matrix = {};
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    auto status = wifi_chip_->getSupportedRadioCombinationsMatrix(&combination_matrix);
-    if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
-        GTEST_SKIP() << "Skipping this test since getSupportedRadioCombinationsMatrix() "
-                        "is not supported by vendor.";
-    }
-    EXPECT_TRUE(status.isOk());
-}
-
-/*
- * SetCountryCode
- */
-TEST_P(WifiChipAidlTest, SetCountryCode) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    std::array<uint8_t, 2> country_code = {0x55, 0x53};
-    EXPECT_TRUE(wifi_chip_->setCountryCode(country_code).isOk());
-}
-
-/*
- * SetLatencyMode_normal
- * Tests the setLatencyMode() API with Latency mode NORMAL.
- */
-TEST_P(WifiChipAidlTest, SetLatencyMode_normal) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    int32_t caps = getChipCapabilities(wifi_chip_);
-    auto status = wifi_chip_->setLatencyMode(IWifiChip::LatencyMode::NORMAL);
-    if (caps & static_cast<int32_t>(IWifiChip::ChipCapabilityMask::SET_LATENCY_MODE)) {
-        EXPECT_TRUE(status.isOk());
-    } else {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/*
- * SetLatencyMode_low
- * Tests the setLatencyMode() API with Latency mode LOW.
- */
-TEST_P(WifiChipAidlTest, SetLatencyMode_low) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    int32_t caps = getChipCapabilities(wifi_chip_);
-    auto status = wifi_chip_->setLatencyMode(IWifiChip::LatencyMode::LOW);
-    if (caps & static_cast<int32_t>(IWifiChip::ChipCapabilityMask::SET_LATENCY_MODE)) {
-        EXPECT_TRUE(status.isOk());
-    } else {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/*
- * SetMultiStaPrimaryConnection
- *
- * Only runs if the device supports 2 STA ifaces.
- */
-TEST_P(WifiChipAidlTest, SetMultiStaPrimaryConnection) {
-    auto ifaces = create2StaIfacesIfPossible();
-    if (ifaces.size() < 2) {
-        GTEST_SKIP() << "Device does not support more than 1 STA concurrently";
-    }
-
-    auto status = wifi_chip_->setMultiStaPrimaryConnection(getStaIfaceName(ifaces[0]));
-    if (!status.isOk()) {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/*
- * SetMultiStaUseCase
- *
- * Only runs if the device supports 2 STA ifaces.
- */
-TEST_P(WifiChipAidlTest, setMultiStaUseCase) {
-    auto ifaces = create2StaIfacesIfPossible();
-    if (ifaces.size() < 2) {
-        GTEST_SKIP() << "Device does not support more than 1 STA concurrently";
-    }
-
-    auto status = wifi_chip_->setMultiStaUseCase(
-            IWifiChip::MultiStaUseCase::DUAL_STA_TRANSIENT_PREFER_PRIMARY);
-    if (!status.isOk()) {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/*
- * SetCoexUnsafeChannels
- */
-TEST_P(WifiChipAidlTest, SetCoexUnsafeChannels) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-
-    // Test with an empty vector of CoexUnsafeChannels.
-    std::vector<IWifiChip::CoexUnsafeChannel> vec;
-    IWifiChip::CoexRestriction restrictions = static_cast<IWifiChip::CoexRestriction>(0);
-    auto status = wifi_chip_->setCoexUnsafeChannels(vec, restrictions);
-    if (!status.isOk()) {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-
-    // Test with a non-empty vector of CoexUnsafeChannels.
-    IWifiChip::CoexUnsafeChannel unsafeChannel24Ghz;
-    unsafeChannel24Ghz.band = WifiBand::BAND_24GHZ;
-    unsafeChannel24Ghz.channel = 6;
-    vec.push_back(unsafeChannel24Ghz);
-    IWifiChip::CoexUnsafeChannel unsafeChannel5Ghz;
-    unsafeChannel5Ghz.band = WifiBand::BAND_5GHZ;
-    unsafeChannel5Ghz.channel = 36;
-    vec.push_back(unsafeChannel5Ghz);
-    restrictions = static_cast<IWifiChip::CoexRestriction>(
-            static_cast<int32_t>(IWifiChip::CoexRestriction::WIFI_AWARE) |
-            static_cast<int32_t>(IWifiChip::CoexRestriction::SOFTAP) |
-            static_cast<int32_t>(IWifiChip::CoexRestriction::WIFI_DIRECT));
-
-    status = wifi_chip_->setCoexUnsafeChannels(vec, restrictions);
-    if (!status.isOk()) {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/*
- * SelectTxPowerScenario - Body
- */
-TEST_P(WifiChipAidlTest, SelectTxPowerScenario_body) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    int32_t caps = getChipCapabilities(wifi_chip_);
-    int32_t expected_caps =
-            static_cast<int32_t>(IWifiChip::ChipCapabilityMask::SET_TX_POWER_LIMIT) |
-            static_cast<int32_t>(IWifiChip::ChipCapabilityMask::USE_BODY_HEAD_SAR);
-    auto status = wifi_chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::ON_BODY_CELL_OFF);
-    if (caps & expected_caps) {
-        EXPECT_TRUE(status.isOk());
-    } else {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/*
- * SelectTxPowerScenario - Voice Call
- */
-TEST_P(WifiChipAidlTest, SelectTxPowerScenario_voiceCall) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    int32_t caps = getChipCapabilities(wifi_chip_);
-    auto status = wifi_chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::VOICE_CALL);
-    if (caps & static_cast<int32_t>(IWifiChip::ChipCapabilityMask::SET_TX_POWER_LIMIT)) {
-        EXPECT_TRUE(status.isOk());
-    } else {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/*
- * ResetTxPowerScenario
- */
-TEST_P(WifiChipAidlTest, ResetTxPowerScenario) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    int32_t caps = getChipCapabilities(wifi_chip_);
-    auto status = wifi_chip_->resetTxPowerScenario();
-    if (caps & static_cast<int32_t>(IWifiChip::ChipCapabilityMask::SET_TX_POWER_LIMIT)) {
-        EXPECT_TRUE(status.isOk());
-    } else {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/*
- * ConfigureChip
- */
-TEST_P(WifiChipAidlTest, ConfigureChip) {
-    std::vector<IWifiChip::ChipMode> modes;
-    EXPECT_TRUE(wifi_chip_->getAvailableModes(&modes).isOk());
-    EXPECT_NE(modes.size(), 0);
-    for (const auto& mode : modes) {
-        // configureChip() requires a fresh IWifiChip object.
-        wifi_chip_ = getWifiChip(getInstanceName());
-        ASSERT_NE(nullptr, wifi_chip_.get());
-        EXPECT_TRUE(wifi_chip_->configureChip(mode.id).isOk());
-        stopWifiService(getInstanceName());
-        // Sleep for 5 milliseconds between each wifi state toggle.
-        usleep(5000);
-    }
-}
-
-/*
- * RequestChipDebugInfo
- */
-TEST_P(WifiChipAidlTest, RequestChipDebugInfo) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    IWifiChip::ChipDebugInfo debug_info = {};
-    EXPECT_TRUE(wifi_chip_->requestChipDebugInfo(&debug_info).isOk());
-    EXPECT_NE(debug_info.driverDescription.size(), 0);
-    EXPECT_NE(debug_info.firmwareDescription.size(), 0);
-}
-
-/*
- * RequestFirmwareDebugDump
- */
-TEST_P(WifiChipAidlTest, RequestFirmwareDebugDump) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    int32_t caps = getChipCapabilities(wifi_chip_);
-    std::vector<uint8_t> debug_dump;
-    auto status = wifi_chip_->requestFirmwareDebugDump(&debug_dump);
-    if (caps & static_cast<int32_t>(IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_FIRMWARE_DUMP)) {
-        EXPECT_TRUE(status.isOk());
-    } else {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/*
- * RequestDriverDebugDump
- */
-TEST_P(WifiChipAidlTest, RequestDriverDebugDump) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    int32_t caps = getChipCapabilities(wifi_chip_);
-    std::vector<uint8_t> debug_dump;
-    auto status = wifi_chip_->requestDriverDebugDump(&debug_dump);
-    if (caps & static_cast<int32_t>(IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_DRIVER_DUMP)) {
-        EXPECT_TRUE(status.isOk());
-    } else {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/*
- * GetDebugRingBuffersStatus
- */
-TEST_P(WifiChipAidlTest, GetDebugRingBuffersStatus) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    int32_t caps = getChipCapabilities(wifi_chip_);
-    std::vector<WifiDebugRingBufferStatus> ring_buffer_status;
-    auto status = wifi_chip_->getDebugRingBuffersStatus(&ring_buffer_status);
-    if (hasAnyRingBufferCapabilities(caps)) {
-        EXPECT_TRUE(status.isOk());
-        ASSERT_NE(ring_buffer_status.size(), 0);
-        for (const auto& ring_buffer : ring_buffer_status) {
-            EXPECT_NE(ring_buffer.ringName.size(), 0);
-        }
-    } else {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/*
- * GetDebugHostWakeReasonStats
- */
-TEST_P(WifiChipAidlTest, GetDebugHostWakeReasonStats) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    int32_t caps = getChipCapabilities(wifi_chip_);
-    WifiDebugHostWakeReasonStats wake_reason_stats = {};
-    auto status = wifi_chip_->getDebugHostWakeReasonStats(&wake_reason_stats);
-    if (caps & static_cast<int32_t>(IWifiChip::ChipCapabilityMask::DEBUG_HOST_WAKE_REASON_STATS)) {
-        EXPECT_TRUE(status.isOk());
-    } else {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/*
- * StartLoggingToDebugRingBuffer
- */
-TEST_P(WifiChipAidlTest, StartLoggingToDebugRingBuffer) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    int32_t caps = getChipCapabilities(wifi_chip_);
-    std::string ring_name;
-    std::vector<WifiDebugRingBufferStatus> ring_buffer_status;
-    auto status = wifi_chip_->getDebugRingBuffersStatus(&ring_buffer_status);
-
-    if (hasAnyRingBufferCapabilities(caps)) {
-        EXPECT_TRUE(status.isOk());
-        ASSERT_NE(ring_buffer_status.size(), 0);
-        ring_name = ring_buffer_status[0].ringName;
-    } else {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-
-    status = wifi_chip_->startLoggingToDebugRingBuffer(
-            ring_name, WifiDebugRingBufferVerboseLevel::VERBOSE, 5, 1024);
-    if (hasAnyRingBufferCapabilities(caps)) {
-        EXPECT_TRUE(status.isOk());
-    } else {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/*
- * ForceDumpToDebugRingBuffer
- */
-TEST_P(WifiChipAidlTest, ForceDumpToDebugRingBuffer) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-    int32_t caps = getChipCapabilities(wifi_chip_);
-    std::string ring_name;
-    std::vector<WifiDebugRingBufferStatus> ring_buffer_status;
-    auto status = wifi_chip_->getDebugRingBuffersStatus(&ring_buffer_status);
-
-    if (hasAnyRingBufferCapabilities(caps)) {
-        EXPECT_TRUE(status.isOk());
-        ASSERT_NE(ring_buffer_status.size(), 0);
-        ring_name = ring_buffer_status[0].ringName;
-    } else {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-
-    status = wifi_chip_->forceDumpToDebugRingBuffer(ring_name);
-    if (hasAnyRingBufferCapabilities(caps)) {
-        EXPECT_TRUE(status.isOk());
-    } else {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/*
- * CreateStaIface
- * Configures the chip in STA mode and creates an iface.
- */
-TEST_P(WifiChipAidlTest, CreateStaIface) {
-    configureChipForStaAndGetIface();
-}
-
-/*
- * CreateApIface
- */
-TEST_P(WifiChipAidlTest, CreateApIface) {
-    configureChipForApAndGetIface();
-}
-
-/*
- * CreateNanIface
- */
-TEST_P(WifiChipAidlTest, CreateNanIface) {
-    configureChipForNanAndGetIface();
-}
-
-/*
- * CreateP2pIface
- */
-TEST_P(WifiChipAidlTest, CreateP2pIface) {
-    configureChipForNanAndGetIface();
-}
-
-/*
- * GetStaIfaceNames
- * Configures the chip in STA mode and ensures that the iface name list is
- * empty before creating the iface. Then create the iface and ensure that
- * iface name is returned in the iface name list.
- */
-TEST_P(WifiChipAidlTest, GetStaIfaceNames) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::STA);
-
-    std::vector<std::string> iface_names;
-    EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
-    EXPECT_EQ(iface_names.size(), 0);
-
-    std::shared_ptr<IWifiStaIface> iface;
-    EXPECT_TRUE(wifi_chip_->createStaIface(&iface).isOk());
-    ASSERT_NE(nullptr, iface.get());
-
-    std::string iface_name = getStaIfaceName(iface);
-    EXPECT_TRUE(wifi_chip_->getStaIfaceNames(&iface_names).isOk());
-    EXPECT_EQ(iface_names.size(), 1);
-    EXPECT_EQ(iface_name, iface_names[0]);
-
-    EXPECT_TRUE(wifi_chip_->removeStaIface(iface_name).isOk());
-    EXPECT_TRUE(wifi_chip_->getStaIfaceNames(&iface_names).isOk());
-    EXPECT_EQ(iface_names.size(), 0);
-}
-
-/*
- * GetP2pIfaceNames
- */
-TEST_P(WifiChipAidlTest, GetP2pIfaceNames) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::P2P);
-
-    std::vector<std::string> iface_names;
-    EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
-    EXPECT_EQ(iface_names.size(), 0);
-
-    std::shared_ptr<IWifiP2pIface> iface;
-    EXPECT_TRUE(wifi_chip_->createP2pIface(&iface).isOk());
-    ASSERT_NE(nullptr, iface.get());
-
-    std::string iface_name = getP2pIfaceName(iface);
-    EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
-    EXPECT_EQ(iface_names.size(), 1);
-    EXPECT_EQ(iface_name, iface_names[0]);
-
-    EXPECT_TRUE(wifi_chip_->removeP2pIface(iface_name).isOk());
-    EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
-    EXPECT_EQ(iface_names.size(), 0);
-}
-
-/*
- * GetApIfaceNames
- */
-TEST_P(WifiChipAidlTest, GetApIfaceNames) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::AP);
-
-    std::vector<std::string> iface_names;
-    EXPECT_TRUE(wifi_chip_->getApIfaceNames(&iface_names).isOk());
-    EXPECT_EQ(iface_names.size(), 0);
-
-    std::shared_ptr<IWifiApIface> iface;
-    EXPECT_TRUE(wifi_chip_->createApIface(&iface).isOk());
-    ASSERT_NE(nullptr, iface.get());
-
-    std::string iface_name = getApIfaceName(iface);
-    EXPECT_TRUE(wifi_chip_->getApIfaceNames(&iface_names).isOk());
-    EXPECT_EQ(iface_names.size(), 1);
-    EXPECT_EQ(iface_name, iface_names[0]);
-
-    EXPECT_TRUE(wifi_chip_->removeApIface(iface_name).isOk());
-    EXPECT_TRUE(wifi_chip_->getApIfaceNames(&iface_names).isOk());
-    EXPECT_EQ(iface_names.size(), 0);
-}
-
-/*
- * GetNanIfaceNames
- */
-TEST_P(WifiChipAidlTest, GetNanIfaceNames) {
-    configureChipForConcurrencyType(IfaceConcurrencyType::NAN_IFACE);
-
-    std::vector<std::string> iface_names;
-    EXPECT_TRUE(wifi_chip_->getNanIfaceNames(&iface_names).isOk());
-    EXPECT_EQ(iface_names.size(), 0);
-
-    std::shared_ptr<IWifiNanIface> iface;
-    EXPECT_TRUE(wifi_chip_->createNanIface(&iface).isOk());
-    ASSERT_NE(nullptr, iface.get());
-
-    std::string iface_name = getNanIfaceName(iface);
-    EXPECT_TRUE(wifi_chip_->getNanIfaceNames(&iface_names).isOk());
-    EXPECT_EQ(iface_names.size(), 1);
-    EXPECT_EQ(iface_name, iface_names[0]);
-
-    EXPECT_TRUE(wifi_chip_->removeNanIface(iface_name).isOk());
-    EXPECT_TRUE(wifi_chip_->getNanIfaceNames(&iface_names).isOk());
-    EXPECT_EQ(iface_names.size(), 0);
-}
-
-/*
- * GetStaIface
- * Configures the chip in STA mode and creates an iface. Then retrieves
- * the iface object using its name and ensures that any other name
- * doesn't retrieve a valid iface object.
- */
-TEST_P(WifiChipAidlTest, GetStaIface) {
-    std::shared_ptr<IWifiStaIface> iface = configureChipForStaAndGetIface();
-    std::string iface_name = getStaIfaceName(iface);
-
-    std::shared_ptr<IWifiStaIface> retrieved_iface;
-    EXPECT_TRUE(wifi_chip_->getStaIface(iface_name, &retrieved_iface).isOk());
-    EXPECT_NE(nullptr, retrieved_iface.get());
-
-    std::string invalid_name = iface_name + "0";
-    std::shared_ptr<IWifiStaIface> invalid_iface;
-    auto status = wifi_chip_->getStaIface(invalid_name, &invalid_iface);
-    EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
-    EXPECT_EQ(nullptr, invalid_iface.get());
-}
-
-/*
- * GetP2pIface
- */
-TEST_P(WifiChipAidlTest, GetP2pIface) {
-    std::shared_ptr<IWifiP2pIface> iface = configureChipForP2pAndGetIface();
-    std::string iface_name = getP2pIfaceName(iface);
-
-    std::shared_ptr<IWifiP2pIface> retrieved_iface;
-    EXPECT_TRUE(wifi_chip_->getP2pIface(iface_name, &retrieved_iface).isOk());
-    EXPECT_NE(nullptr, retrieved_iface.get());
-
-    std::string invalid_name = iface_name + "0";
-    std::shared_ptr<IWifiP2pIface> invalid_iface;
-    auto status = wifi_chip_->getP2pIface(invalid_name, &invalid_iface);
-    EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
-    EXPECT_EQ(nullptr, invalid_iface.get());
-}
-
-/*
- * GetApIface
- */
-TEST_P(WifiChipAidlTest, GetApIface) {
-    std::shared_ptr<IWifiApIface> iface = configureChipForApAndGetIface();
-    std::string iface_name = getApIfaceName(iface);
-
-    std::shared_ptr<IWifiApIface> retrieved_iface;
-    EXPECT_TRUE(wifi_chip_->getApIface(iface_name, &retrieved_iface).isOk());
-    EXPECT_NE(nullptr, retrieved_iface.get());
-
-    std::string invalid_name = iface_name + "0";
-    std::shared_ptr<IWifiApIface> invalid_iface;
-    auto status = wifi_chip_->getApIface(invalid_name, &invalid_iface);
-    EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
-    EXPECT_EQ(nullptr, invalid_iface.get());
-}
-
-/*
- * GetNanIface
- */
-TEST_P(WifiChipAidlTest, GetNanIface) {
-    std::shared_ptr<IWifiNanIface> iface = configureChipForNanAndGetIface();
-    std::string iface_name = getNanIfaceName(iface);
-
-    std::shared_ptr<IWifiNanIface> retrieved_iface;
-    EXPECT_TRUE(wifi_chip_->getNanIface(iface_name, &retrieved_iface).isOk());
-    EXPECT_NE(nullptr, retrieved_iface.get());
-
-    std::string invalid_name = iface_name + "0";
-    std::shared_ptr<IWifiNanIface> invalid_iface;
-    auto status = wifi_chip_->getNanIface(invalid_name, &invalid_iface);
-    EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
-    EXPECT_EQ(nullptr, invalid_iface.get());
-}
-
-/*
- * RemoveStaIface
- * Configures the chip in STA mode and creates an iface. Then removes
- * the iface object using the correct name and ensures that any other
- * name doesn't remove the iface.
- */
-TEST_P(WifiChipAidlTest, RemoveStaIface) {
-    std::shared_ptr<IWifiStaIface> iface = configureChipForStaAndGetIface();
-    std::string iface_name = getStaIfaceName(iface);
-
-    std::string invalid_name = iface_name + "0";
-    auto status = wifi_chip_->removeStaIface(invalid_name);
-    EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
-    EXPECT_TRUE(wifi_chip_->removeStaIface(iface_name).isOk());
-
-    // No such iface exists now, so this should return failure.
-    EXPECT_FALSE(wifi_chip_->removeStaIface(iface_name).isOk());
-}
-
-/*
- * RemoveP2pIface
- */
-TEST_P(WifiChipAidlTest, RemoveP2pIface) {
-    std::shared_ptr<IWifiP2pIface> iface = configureChipForP2pAndGetIface();
-    std::string iface_name = getP2pIfaceName(iface);
-
-    std::string invalid_name = iface_name + "0";
-    auto status = wifi_chip_->removeP2pIface(invalid_name);
-    EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
-    EXPECT_TRUE(wifi_chip_->removeP2pIface(iface_name).isOk());
-
-    // No such iface exists now, so this should return failure.
-    EXPECT_FALSE(wifi_chip_->removeP2pIface(iface_name).isOk());
-}
-
-/*
- * RemoveApIface
- */
-TEST_P(WifiChipAidlTest, RemoveApIface) {
-    std::shared_ptr<IWifiApIface> iface = configureChipForApAndGetIface();
-    std::string iface_name = getApIfaceName(iface);
-
-    std::string invalid_name = iface_name + "0";
-    auto status = wifi_chip_->removeApIface(invalid_name);
-    EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
-    EXPECT_TRUE(wifi_chip_->removeApIface(iface_name).isOk());
-
-    // No such iface exists now, so this should return failure.
-    EXPECT_FALSE(wifi_chip_->removeApIface(iface_name).isOk());
-}
-
-/*
- * RemoveNanIface
- */
-TEST_P(WifiChipAidlTest, RemoveNanIface) {
-    std::shared_ptr<IWifiNanIface> iface = configureChipForNanAndGetIface();
-    std::string iface_name = getNanIfaceName(iface);
-
-    std::string invalid_name = iface_name + "0";
-    auto status = wifi_chip_->removeNanIface(invalid_name);
-    EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
-    EXPECT_TRUE(wifi_chip_->removeNanIface(iface_name).isOk());
-
-    // No such iface exists now, so this should return failure.
-    EXPECT_FALSE(wifi_chip_->removeNanIface(iface_name).isOk());
-}
-
-/*
- * CreateRttController
- */
-TEST_P(WifiChipAidlTest, CreateRttController) {
-    std::shared_ptr<IWifiStaIface> iface = configureChipForStaAndGetIface();
-    std::shared_ptr<IWifiRttController> rtt_controller;
-    auto status = wifi_chip_->createRttController(iface, &rtt_controller);
-    if (status.isOk()) {
-        EXPECT_NE(nullptr, rtt_controller.get());
-    } else {
-        EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-    }
-}
-
-/**
- * CreateBridgedApIface & RemoveIfaceInstanceFromBridgedApIface
- */
-TEST_P(WifiChipAidlTest, CreateBridgedApIfaceAndremoveIfaceInstanceFromBridgedApIfaceTest) {
-    bool isBridgedSupport = testing::checkSubstringInCommandOutput(
-            "/system/bin/cmd wifi get-softap-supported-features",
-            "wifi_softap_bridged_ap_supported");
-    if (!isBridgedSupport) {
-        GTEST_SKIP() << "Missing Bridged AP support";
-    }
-
-    std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(getInstanceName());
-    ASSERT_NE(nullptr, wifi_chip.get());
-    std::shared_ptr<IWifiApIface> wifi_ap_iface = getBridgedWifiApIface(wifi_chip);
-    ASSERT_NE(nullptr, wifi_ap_iface.get());
-
-    std::string br_name;
-    std::vector<std::string> instances;
-    EXPECT_TRUE(wifi_ap_iface->getName(&br_name).isOk());
-    EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances).isOk());
-    EXPECT_EQ(instances.size(), 2);
-
-    std::vector<std::string> instances_after_remove;
-    EXPECT_TRUE(wifi_chip->removeIfaceInstanceFromBridgedApIface(br_name, instances[0]).isOk());
-    EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances_after_remove).isOk());
-    EXPECT_EQ(instances_after_remove.size(), 1);
-}
-
-GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiChipAidlTest);
-INSTANTIATE_TEST_SUITE_P(WifiTest, WifiChipAidlTest,
-                         testing::ValuesIn(android::getAidlHalInstanceNames(IWifi::descriptor)),
-                         android::PrintInstanceNameToString);
-
-int main(int argc, char** argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-    android::ProcessState::self()->setThreadPoolMaxThreadCount(1);
-    android::ProcessState::self()->startThreadPool();
-    return RUN_ALL_TESTS();
-}
diff --git a/wifi/aidl/vts/functional/wifi_nan_iface_aidl_test.cpp b/wifi/aidl/vts/functional/wifi_nan_iface_aidl_test.cpp
deleted file mode 100644
index 457d57a..0000000
--- a/wifi/aidl/vts/functional/wifi_nan_iface_aidl_test.cpp
+++ /dev/null
@@ -1,627 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Staache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <vector>
-
-#include <VtsCoreUtil.h>
-#include <aidl/Gtest.h>
-#include <aidl/Vintf.h>
-#include <aidl/android/hardware/wifi/BnWifi.h>
-#include <aidl/android/hardware/wifi/BnWifiNanIfaceEventCallback.h>
-#include <aidl/android/hardware/wifi/NanBandIndex.h>
-#include <android/binder_manager.h>
-#include <android/binder_status.h>
-#include <binder/IServiceManager.h>
-#include <binder/ProcessState.h>
-
-#include "wifi_aidl_test_utils.h"
-
-using aidl::android::hardware::wifi::BnWifiNanIfaceEventCallback;
-using aidl::android::hardware::wifi::IWifiNanIface;
-using aidl::android::hardware::wifi::NanBandIndex;
-using aidl::android::hardware::wifi::NanBandSpecificConfig;
-using aidl::android::hardware::wifi::NanCapabilities;
-using aidl::android::hardware::wifi::NanClusterEventInd;
-using aidl::android::hardware::wifi::NanConfigRequest;
-using aidl::android::hardware::wifi::NanConfigRequestSupplemental;
-using aidl::android::hardware::wifi::NanDataPathConfirmInd;
-using aidl::android::hardware::wifi::NanDataPathRequestInd;
-using aidl::android::hardware::wifi::NanDataPathScheduleUpdateInd;
-using aidl::android::hardware::wifi::NanDataPathSecurityType;
-using aidl::android::hardware::wifi::NanEnableRequest;
-using aidl::android::hardware::wifi::NanFollowupReceivedInd;
-using aidl::android::hardware::wifi::NanInitiateDataPathRequest;
-using aidl::android::hardware::wifi::NanMatchAlg;
-using aidl::android::hardware::wifi::NanMatchInd;
-using aidl::android::hardware::wifi::NanPublishRequest;
-using aidl::android::hardware::wifi::NanPublishType;
-using aidl::android::hardware::wifi::NanRespondToDataPathIndicationRequest;
-using aidl::android::hardware::wifi::NanStatus;
-using aidl::android::hardware::wifi::NanStatusCode;
-using aidl::android::hardware::wifi::NanTxType;
-
-#define TIMEOUT_PERIOD 10
-
-class WifiNanIfaceAidlTest : public testing::TestWithParam<std::string> {
-  public:
-    void SetUp() override {
-        if (!::testing::deviceSupportsFeature("android.hardware.wifi.aware"))
-            GTEST_SKIP() << "Skipping this test since NAN is not supported.";
-        stopWifiService(getInstanceName());
-
-        wifi_nan_iface_ = getWifiNanIface(getInstanceName());
-        ASSERT_NE(nullptr, wifi_nan_iface_.get());
-        std::shared_ptr<WifiNanIfaceEventCallback> callback =
-                ndk::SharedRefBase::make<WifiNanIfaceEventCallback>(*this);
-        EXPECT_TRUE(wifi_nan_iface_->registerEventCallback(callback).isOk());
-    }
-
-    void TearDown() override { stopWifiService(getInstanceName()); }
-
-    // Used as a mechanism to inform the test about data/event callbacks.
-    inline void notify() {
-        std::unique_lock<std::mutex> lock(mtx_);
-        count_++;
-        cv_.notify_one();
-    }
-
-    enum CallbackType {
-        INVALID = -2,
-        ANY_CALLBACK = -1,
-
-        NOTIFY_CAPABILITIES_RESPONSE = 0,
-        NOTIFY_ENABLE_RESPONSE,
-        NOTIFY_CONFIG_RESPONSE,
-        NOTIFY_DISABLE_RESPONSE,
-        NOTIFY_START_PUBLISH_RESPONSE,
-        NOTIFY_STOP_PUBLISH_RESPONSE,
-        NOTIFY_START_SUBSCRIBE_RESPONSE,
-        NOTIFY_STOP_SUBSCRIBE_RESPONSE,
-        NOTIFY_TRANSMIT_FOLLOWUP_RESPONSE,
-        NOTIFY_CREATE_DATA_INTERFACE_RESPONSE,
-        NOTIFY_DELETE_DATA_INTERFACE_RESPONSE,
-        NOTIFY_INITIATE_DATA_PATH_RESPONSE,
-        NOTIFY_RESPOND_TO_DATA_PATH_INDICATION_RESPONSE,
-        NOTIFY_TERMINATE_DATA_PATH_RESPONSE,
-
-        EVENT_CLUSTER_EVENT,
-        EVENT_DISABLED,
-        EVENT_PUBLISH_TERMINATED,
-        EVENT_SUBSCRIBE_TERMINATED,
-        EVENT_MATCH,
-        EVENT_MATCH_EXPIRED,
-        EVENT_FOLLOWUP_RECEIVED,
-        EVENT_TRANSMIT_FOLLOWUP,
-        EVENT_DATA_PATH_REQUEST,
-        EVENT_DATA_PATH_CONFIRM,
-        EVENT_DATA_PATH_TERMINATED,
-        EVENT_DATA_PATH_SCHEDULE_UPDATE,
-    };
-
-    // Test code calls this function to wait for data/event callback.
-    // Must set callbackType = INVALID before calling this function.
-    inline std::cv_status wait(CallbackType waitForCallbackType) {
-        std::unique_lock<std::mutex> lock(mtx_);
-        EXPECT_NE(INVALID, waitForCallbackType);
-
-        std::cv_status status = std::cv_status::no_timeout;
-        auto now = std::chrono::system_clock::now();
-        while (count_ == 0) {
-            status = cv_.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD));
-            if (status == std::cv_status::timeout) return status;
-            if (waitForCallbackType != ANY_CALLBACK && callback_type_ != INVALID &&
-                callback_type_ != waitForCallbackType) {
-                count_--;
-            }
-        }
-        count_--;
-        return status;
-    }
-
-    class WifiNanIfaceEventCallback : public BnWifiNanIfaceEventCallback {
-      public:
-        WifiNanIfaceEventCallback(WifiNanIfaceAidlTest& parent) : parent_(parent){};
-
-        ::ndk::ScopedAStatus eventClusterEvent(const NanClusterEventInd& event) override {
-            parent_.callback_type_ = EVENT_CLUSTER_EVENT;
-            parent_.nan_cluster_event_ind_ = event;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus eventDataPathConfirm(const NanDataPathConfirmInd& event) override {
-            parent_.callback_type_ = EVENT_DATA_PATH_CONFIRM;
-            parent_.nan_data_path_confirm_ind_ = event;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus eventDataPathRequest(const NanDataPathRequestInd& event) override {
-            parent_.callback_type_ = EVENT_DATA_PATH_REQUEST;
-            parent_.nan_data_path_request_ind_ = event;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus eventDataPathScheduleUpdate(
-                const NanDataPathScheduleUpdateInd& event) override {
-            parent_.callback_type_ = EVENT_DATA_PATH_SCHEDULE_UPDATE;
-            parent_.nan_data_path_schedule_update_ind_ = event;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus eventDataPathTerminated(int32_t ndpInstanceId) override {
-            parent_.callback_type_ = EVENT_DATA_PATH_TERMINATED;
-            parent_.ndp_instance_id_ = ndpInstanceId;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus eventDisabled(const NanStatus& status) override {
-            parent_.callback_type_ = EVENT_DISABLED;
-            parent_.status_ = status;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus eventFollowupReceived(const NanFollowupReceivedInd& event) override {
-            parent_.callback_type_ = EVENT_FOLLOWUP_RECEIVED;
-            parent_.nan_followup_received_ind_ = event;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus eventMatch(const NanMatchInd& event) override {
-            parent_.callback_type_ = EVENT_MATCH;
-            parent_.nan_match_ind_ = event;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus eventMatchExpired(int8_t discoverySessionId, int32_t peerId) override {
-            parent_.callback_type_ = EVENT_MATCH_EXPIRED;
-            parent_.session_id_ = discoverySessionId;
-            parent_.peer_id_ = peerId;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus eventPublishTerminated(int8_t sessionId,
-                                                    const NanStatus& status) override {
-            parent_.callback_type_ = EVENT_PUBLISH_TERMINATED;
-            parent_.session_id_ = sessionId;
-            parent_.status_ = status;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus eventSubscribeTerminated(int8_t sessionId,
-                                                      const NanStatus& status) override {
-            parent_.callback_type_ = EVENT_SUBSCRIBE_TERMINATED;
-            parent_.session_id_ = sessionId;
-            parent_.status_ = status;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus eventTransmitFollowup(char16_t id, const NanStatus& status) override {
-            parent_.callback_type_ = EVENT_TRANSMIT_FOLLOWUP;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus notifyCapabilitiesResponse(
-                char16_t id, const NanStatus& status,
-                const NanCapabilities& capabilities) override {
-            parent_.callback_type_ = NOTIFY_CAPABILITIES_RESPONSE;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.capabilities_ = capabilities;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus notifyConfigResponse(char16_t id, const NanStatus& status) override {
-            parent_.callback_type_ = NOTIFY_CONFIG_RESPONSE;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus notifyCreateDataInterfaceResponse(char16_t id,
-                                                               const NanStatus& status) override {
-            parent_.callback_type_ = NOTIFY_CREATE_DATA_INTERFACE_RESPONSE;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus notifyDeleteDataInterfaceResponse(char16_t id,
-                                                               const NanStatus& status) override {
-            parent_.callback_type_ = NOTIFY_DELETE_DATA_INTERFACE_RESPONSE;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus notifyDisableResponse(char16_t id, const NanStatus& status) override {
-            parent_.callback_type_ = NOTIFY_DISABLE_RESPONSE;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus notifyEnableResponse(char16_t id, const NanStatus& status) override {
-            parent_.callback_type_ = NOTIFY_ENABLE_RESPONSE;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus notifyInitiateDataPathResponse(char16_t id, const NanStatus& status,
-                                                            int32_t ndpInstanceId) override {
-            parent_.callback_type_ = NOTIFY_INITIATE_DATA_PATH_RESPONSE;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.ndp_instance_id_ = ndpInstanceId;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus notifyRespondToDataPathIndicationResponse(
-                char16_t id, const NanStatus& status) override {
-            parent_.callback_type_ = NOTIFY_RESPOND_TO_DATA_PATH_INDICATION_RESPONSE;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus notifyStartPublishResponse(char16_t id, const NanStatus& status,
-                                                        int8_t sessionId) override {
-            parent_.callback_type_ = NOTIFY_START_PUBLISH_RESPONSE;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.session_id_ = sessionId;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus notifyStartSubscribeResponse(char16_t id, const NanStatus& status,
-                                                          int8_t sessionId) override {
-            parent_.callback_type_ = NOTIFY_START_SUBSCRIBE_RESPONSE;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.session_id_ = sessionId;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus notifyStopPublishResponse(char16_t id,
-                                                       const NanStatus& status) override {
-            parent_.callback_type_ = NOTIFY_STOP_PUBLISH_RESPONSE;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus notifyStopSubscribeResponse(char16_t id,
-                                                         const NanStatus& status) override {
-            parent_.callback_type_ = NOTIFY_STOP_SUBSCRIBE_RESPONSE;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus notifyTerminateDataPathResponse(char16_t id,
-                                                             const NanStatus& status) override {
-            parent_.callback_type_ = NOTIFY_TERMINATE_DATA_PATH_RESPONSE;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-        ::ndk::ScopedAStatus notifyTransmitFollowupResponse(char16_t id,
-                                                            const NanStatus& status) override {
-            parent_.callback_type_ = NOTIFY_TRANSMIT_FOLLOWUP_RESPONSE;
-            parent_.id_ = id;
-            parent_.status_ = status;
-            parent_.notify();
-            return ndk::ScopedAStatus::ok();
-        }
-
-      private:
-        WifiNanIfaceAidlTest& parent_;
-    };
-
-  protected:
-    std::shared_ptr<IWifiNanIface> wifi_nan_iface_;
-    CallbackType callback_type_;
-    uint16_t id_;
-    uint8_t session_id_;
-    uint32_t ndp_instance_id_;
-    uint32_t peer_id_;
-    NanCapabilities capabilities_;
-    NanClusterEventInd nan_cluster_event_ind_;
-    NanDataPathConfirmInd nan_data_path_confirm_ind_;
-    NanDataPathRequestInd nan_data_path_request_ind_;
-    NanDataPathScheduleUpdateInd nan_data_path_schedule_update_ind_;
-    NanFollowupReceivedInd nan_followup_received_ind_;
-    NanMatchInd nan_match_ind_;
-    NanStatus status_;
-
-    const char* getInstanceName() { return GetParam().c_str(); }
-
-  private:
-    // synchronization objects
-    std::mutex mtx_;
-    std::condition_variable cv_;
-    int count_ = 0;
-};
-
-/*
- * FailOnIfaceInvalid
- * Ensure that API calls to an interface fail with code ERROR_WIFI_IFACE_INVALID
- * after wifi is disabled.
- */
-TEST_P(WifiNanIfaceAidlTest, FailOnIfaceInvalid) {
-    stopWifiService(getInstanceName());
-    sleep(5);  // Ensure that all chips/interfaces are invalidated.
-    auto status = wifi_nan_iface_->getCapabilitiesRequest(0);
-    ASSERT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_WIFI_IFACE_INVALID));
-}
-
-/*
- * EnableRequest - Invalid Args
- */
-TEST_P(WifiNanIfaceAidlTest, EnableRequest_InvalidArgs) {
-    uint16_t inputCmdId = 10;
-    callback_type_ = INVALID;
-    NanEnableRequest nanEnableRequest = {};
-    NanConfigRequestSupplemental nanConfigRequestSupp = {};
-    auto status =
-            wifi_nan_iface_->enableRequest(inputCmdId, nanEnableRequest, nanConfigRequestSupp);
-    if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
-        ASSERT_TRUE(status.isOk());
-
-        // Wait for a callback.
-        ASSERT_EQ(std::cv_status::no_timeout, wait(NOTIFY_ENABLE_RESPONSE));
-        ASSERT_EQ(NOTIFY_ENABLE_RESPONSE, callback_type_);
-        ASSERT_EQ(id_, inputCmdId);
-        ASSERT_EQ(status_.status, NanStatusCode::INVALID_ARGS);
-    }
-}
-
-/*
- * ConfigRequest - Invalid Args
- */
-TEST_P(WifiNanIfaceAidlTest, ConfigRequest_InvalidArgs) {
-    uint16_t inputCmdId = 10;
-    callback_type_ = INVALID;
-    NanConfigRequest nanConfigRequest = {};
-    NanConfigRequestSupplemental nanConfigRequestSupp = {};
-    auto status =
-            wifi_nan_iface_->configRequest(inputCmdId, nanConfigRequest, nanConfigRequestSupp);
-
-    if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
-        ASSERT_TRUE(status.isOk());
-
-        // Wait for a callback.
-        ASSERT_EQ(std::cv_status::no_timeout, wait(NOTIFY_CONFIG_RESPONSE));
-        ASSERT_EQ(NOTIFY_CONFIG_RESPONSE, callback_type_);
-        ASSERT_EQ(id_, inputCmdId);
-        ASSERT_EQ(status_.status, NanStatusCode::INVALID_ARGS);
-    }
-}
-
-/*
- * EnableRequest - Invalid Args in Shim Conversion
- */
-TEST_P(WifiNanIfaceAidlTest, EnableRequest_InvalidShimArgs) {
-    uint16_t inputCmdId = 10;
-    NanEnableRequest nanEnableRequest = {};
-    nanEnableRequest.configParams.numberOfPublishServiceIdsInBeacon = -15;  // must be > 0
-    NanConfigRequestSupplemental nanConfigRequestSupp = {};
-    auto status =
-            wifi_nan_iface_->enableRequest(inputCmdId, nanEnableRequest, nanConfigRequestSupp);
-    if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
-        ASSERT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
-    }
-}
-
-/*
- * ConfigRequest - Invalid Args in Shim Conversion
- */
-TEST_P(WifiNanIfaceAidlTest, ConfigRequest_InvalidShimArgs) {
-    uint16_t inputCmdId = 10;
-    NanConfigRequest nanConfigRequest = {};
-    nanConfigRequest.numberOfPublishServiceIdsInBeacon = -15;  // must be > 0
-    NanConfigRequestSupplemental nanConfigRequestSupp = {};
-    auto status =
-            wifi_nan_iface_->configRequest(inputCmdId, nanConfigRequest, nanConfigRequestSupp);
-    if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
-        ASSERT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
-    }
-}
-
-/*
- * NotifyCapabilitiesResponse
- */
-TEST_P(WifiNanIfaceAidlTest, NotifyCapabilitiesResponse) {
-    uint16_t inputCmdId = 10;
-    callback_type_ = INVALID;
-    EXPECT_TRUE(wifi_nan_iface_->getCapabilitiesRequest(inputCmdId).isOk());
-
-    // Wait for a callback.
-    ASSERT_EQ(std::cv_status::no_timeout, wait(NOTIFY_CAPABILITIES_RESPONSE));
-    ASSERT_EQ(NOTIFY_CAPABILITIES_RESPONSE, callback_type_);
-    ASSERT_EQ(id_, inputCmdId);
-    ASSERT_EQ(status_.status, NanStatusCode::SUCCESS);
-
-    // Check for reasonable capability values.
-    EXPECT_GT(capabilities_.maxConcurrentClusters, 0);
-    EXPECT_GT(capabilities_.maxPublishes, 0);
-    EXPECT_GT(capabilities_.maxSubscribes, 0);
-    EXPECT_EQ(capabilities_.maxServiceNameLen, 255);
-    EXPECT_EQ(capabilities_.maxMatchFilterLen, 255);
-    EXPECT_GT(capabilities_.maxTotalMatchFilterLen, 255);
-    EXPECT_EQ(capabilities_.maxServiceSpecificInfoLen, 255);
-    EXPECT_GE(capabilities_.maxExtendedServiceSpecificInfoLen, 255);
-    EXPECT_GT(capabilities_.maxNdiInterfaces, 0);
-    EXPECT_GT(capabilities_.maxNdpSessions, 0);
-    EXPECT_GT(capabilities_.maxAppInfoLen, 0);
-    EXPECT_GT(capabilities_.maxQueuedTransmitFollowupMsgs, 0);
-    EXPECT_GT(capabilities_.maxSubscribeInterfaceAddresses, 0);
-    EXPECT_NE(static_cast<int32_t>(capabilities_.supportedCipherSuites), 0);
-}
-
-/*
- * StartPublishRequest
- */
-TEST_P(WifiNanIfaceAidlTest, StartPublishRequest) {
-    uint16_t inputCmdId = 10;
-    NanBandSpecificConfig config24 = {};
-    config24.rssiClose = 60;
-    config24.rssiMiddle = 70;
-    config24.rssiCloseProximity = 60;
-    config24.dwellTimeMs = 200;
-    config24.scanPeriodSec = 20;
-    config24.validDiscoveryWindowIntervalVal = false;
-    config24.discoveryWindowIntervalVal = 0;
-
-    NanBandSpecificConfig config5 = {};
-    config5.rssiClose = 60;
-    config5.rssiMiddle = 75;
-    config5.rssiCloseProximity = 60;
-    config5.dwellTimeMs = 200;
-    config5.scanPeriodSec = 20;
-    config5.validDiscoveryWindowIntervalVal = false;
-    config5.discoveryWindowIntervalVal = 0;
-
-    NanEnableRequest req = {};
-    req.operateInBand[static_cast<int32_t>(NanBandIndex::NAN_BAND_24GHZ)] = true;
-    req.operateInBand[static_cast<int32_t>(NanBandIndex::NAN_BAND_5GHZ)] = false;
-    req.hopCountMax = 2;
-    req.configParams.masterPref = 0;
-    req.configParams.disableDiscoveryAddressChangeIndication = true;
-    req.configParams.disableStartedClusterIndication = true;
-    req.configParams.disableJoinedClusterIndication = true;
-    req.configParams.includePublishServiceIdsInBeacon = true;
-    req.configParams.numberOfPublishServiceIdsInBeacon = 0;
-    req.configParams.includeSubscribeServiceIdsInBeacon = true;
-    req.configParams.numberOfSubscribeServiceIdsInBeacon = 0;
-    req.configParams.rssiWindowSize = 8;
-    req.configParams.macAddressRandomizationIntervalSec = 1800;
-    req.configParams.bandSpecificConfig[static_cast<int32_t>(NanBandIndex::NAN_BAND_24GHZ)] =
-            config24;
-    req.configParams.bandSpecificConfig[static_cast<int32_t>(NanBandIndex::NAN_BAND_5GHZ)] =
-            config5;
-
-    req.debugConfigs.validClusterIdVals = true;
-    req.debugConfigs.clusterIdTopRangeVal = 65535;
-    req.debugConfigs.clusterIdBottomRangeVal = 0;
-    req.debugConfigs.validIntfAddrVal = false;
-    req.debugConfigs.validOuiVal = false;
-    req.debugConfigs.ouiVal = 0;
-    req.debugConfigs.validRandomFactorForceVal = false;
-    req.debugConfigs.randomFactorForceVal = 0;
-    req.debugConfigs.validHopCountForceVal = false;
-    req.debugConfigs.hopCountForceVal = 0;
-    req.debugConfigs.validDiscoveryChannelVal = false;
-    req.debugConfigs.discoveryChannelMhzVal[static_cast<int32_t>(NanBandIndex::NAN_BAND_24GHZ)] = 0;
-    req.debugConfigs.discoveryChannelMhzVal[static_cast<int32_t>(NanBandIndex::NAN_BAND_5GHZ)] = 0;
-    req.debugConfigs.validUseBeaconsInBandVal = false;
-    req.debugConfigs.useBeaconsInBandVal[static_cast<int32_t>(NanBandIndex::NAN_BAND_24GHZ)] = true;
-    req.debugConfigs.useBeaconsInBandVal[static_cast<int32_t>(NanBandIndex::NAN_BAND_5GHZ)] = true;
-    req.debugConfigs.validUseSdfInBandVal = false;
-    req.debugConfigs.useSdfInBandVal[static_cast<int32_t>(NanBandIndex::NAN_BAND_24GHZ)] = true;
-    req.debugConfigs.useSdfInBandVal[static_cast<int32_t>(NanBandIndex::NAN_BAND_5GHZ)] = true;
-
-    NanConfigRequestSupplemental nanConfigRequestSupp = {};
-    nanConfigRequestSupp.discoveryBeaconIntervalMs = 20;
-    nanConfigRequestSupp.numberOfSpatialStreamsInDiscovery = 0;
-    nanConfigRequestSupp.enableDiscoveryWindowEarlyTermination = false;
-
-    callback_type_ = INVALID;
-    auto status = wifi_nan_iface_->enableRequest(inputCmdId, req, nanConfigRequestSupp);
-    if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
-        ASSERT_TRUE(status.isOk());
-
-        // Wait for a callback.
-        ASSERT_EQ(std::cv_status::no_timeout, wait(NOTIFY_ENABLE_RESPONSE));
-        ASSERT_EQ(NOTIFY_ENABLE_RESPONSE, callback_type_);
-        ASSERT_EQ(id_, inputCmdId);
-        ASSERT_EQ(status_.status, NanStatusCode::SUCCESS);
-    }
-
-    NanPublishRequest nanPublishRequest = {};
-    nanPublishRequest.baseConfigs.sessionId = 0;
-    nanPublishRequest.baseConfigs.ttlSec = 0;
-    nanPublishRequest.baseConfigs.discoveryWindowPeriod = 1;
-    nanPublishRequest.baseConfigs.discoveryCount = 0;
-    nanPublishRequest.baseConfigs.serviceName = {97};
-    nanPublishRequest.baseConfigs.discoveryMatchIndicator = NanMatchAlg::MATCH_NEVER;
-    nanPublishRequest.baseConfigs.useRssiThreshold = false;
-    nanPublishRequest.baseConfigs.disableDiscoveryTerminationIndication = false;
-    nanPublishRequest.baseConfigs.disableMatchExpirationIndication = true;
-    nanPublishRequest.baseConfigs.disableFollowupReceivedIndication = false;
-    nanPublishRequest.baseConfigs.securityConfig.securityType = NanDataPathSecurityType::OPEN;
-    nanPublishRequest.autoAcceptDataPathRequests = false;
-    nanPublishRequest.publishType = NanPublishType::UNSOLICITED;
-    nanPublishRequest.txType = NanTxType::BROADCAST;
-
-    status = wifi_nan_iface_->startPublishRequest(inputCmdId + 1, nanPublishRequest);
-    if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
-        ASSERT_TRUE(status.isOk());
-
-        // Wait for a callback.
-        ASSERT_EQ(std::cv_status::no_timeout, wait(NOTIFY_START_PUBLISH_RESPONSE));
-        ASSERT_EQ(NOTIFY_START_PUBLISH_RESPONSE, callback_type_);
-        ASSERT_EQ(id_, inputCmdId + 1);
-        ASSERT_EQ(status_.status, NanStatusCode::SUCCESS);
-    }
-}
-
-/*
- * RespondToDataPathIndicationRequest - Invalid Args
- */
-TEST_P(WifiNanIfaceAidlTest, RespondToDataPathIndicationRequest_InvalidArgs) {
-    uint16_t inputCmdId = 10;
-    callback_type_ = INVALID;
-    NanRespondToDataPathIndicationRequest nanRespondToDataPathIndicationRequest = {};
-    nanRespondToDataPathIndicationRequest.ifaceName = "AwareInterfaceNameTooLong";
-    auto status = wifi_nan_iface_->respondToDataPathIndicationRequest(
-            inputCmdId, nanRespondToDataPathIndicationRequest);
-
-    if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
-        ASSERT_EQ(status.getServiceSpecificError(),
-                  static_cast<int32_t>(WifiStatusCode::ERROR_INVALID_ARGS));
-    }
-}
-
-/*
- * InitiateDataPathRequest - Invalid Args
- */
-TEST_P(WifiNanIfaceAidlTest, InitiateDataPathRequest_InvalidArgs) {
-    uint16_t inputCmdId = 10;
-    callback_type_ = INVALID;
-    NanInitiateDataPathRequest nanInitiateDataPathRequest = {};
-    nanInitiateDataPathRequest.ifaceName = "AwareInterfaceNameTooLong";
-    auto status = wifi_nan_iface_->initiateDataPathRequest(inputCmdId, nanInitiateDataPathRequest);
-
-    if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
-        ASSERT_EQ(status.getServiceSpecificError(),
-                  static_cast<int32_t>(WifiStatusCode::ERROR_INVALID_ARGS));
-    }
-}
-
-GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiNanIfaceAidlTest);
-INSTANTIATE_TEST_SUITE_P(WifiTest, WifiNanIfaceAidlTest,
-                         testing::ValuesIn(android::getAidlHalInstanceNames(IWifi::descriptor)),
-                         android::PrintInstanceNameToString);
-
-int main(int argc, char** argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-    android::ProcessState::self()->setThreadPoolMaxThreadCount(1);
-    android::ProcessState::self()->startThreadPool();
-    return RUN_ALL_TESTS();
-}
diff --git a/wifi/aidl/vts/functional/wifi_rtt_controller_aidl_test.cpp b/wifi/aidl/vts/functional/wifi_rtt_controller_aidl_test.cpp
deleted file mode 100644
index d763fe6..0000000
--- a/wifi/aidl/vts/functional/wifi_rtt_controller_aidl_test.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Staache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <vector>
-
-#include <VtsCoreUtil.h>
-#include <aidl/Gtest.h>
-#include <aidl/Vintf.h>
-#include <aidl/android/hardware/wifi/BnWifi.h>
-#include <aidl/android/hardware/wifi/BnWifiRttControllerEventCallback.h>
-#include <android/binder_manager.h>
-#include <android/binder_status.h>
-#include <binder/IServiceManager.h>
-#include <binder/ProcessState.h>
-
-#include "wifi_aidl_test_utils.h"
-
-using aidl::android::hardware::wifi::BnWifiRttControllerEventCallback;
-using aidl::android::hardware::wifi::IWifiRttController;
-using aidl::android::hardware::wifi::RttBw;
-using aidl::android::hardware::wifi::RttCapabilities;
-using aidl::android::hardware::wifi::RttConfig;
-using aidl::android::hardware::wifi::RttPeerType;
-using aidl::android::hardware::wifi::RttPreamble;
-using aidl::android::hardware::wifi::RttResponder;
-using aidl::android::hardware::wifi::RttResult;
-using aidl::android::hardware::wifi::RttType;
-using aidl::android::hardware::wifi::WifiChannelInfo;
-using aidl::android::hardware::wifi::WifiChannelWidthInMhz;
-using aidl::android::hardware::wifi::WifiStatusCode;
-
-class WifiRttControllerAidlTest : public testing::TestWithParam<std::string> {
-  public:
-    void SetUp() override {
-        if (!::testing::deviceSupportsFeature("android.hardware.wifi.rtt"))
-            GTEST_SKIP() << "Skipping this test since RTT is not supported.";
-        stopWifiService(getInstanceName());
-        wifi_rtt_controller_ = getWifiRttController();
-        ASSERT_NE(nullptr, wifi_rtt_controller_.get());
-
-        // Check RTT support before we run the test.
-        RttCapabilities caps = {};
-        auto status = wifi_rtt_controller_->getCapabilities(&caps);
-        if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
-            GTEST_SKIP() << "Skipping this test since RTT is not supported.";
-        }
-    }
-
-    void TearDown() override { stopWifiService(getInstanceName()); }
-
-  protected:
-    std::shared_ptr<IWifiRttController> getWifiRttController() {
-        std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(getInstanceName());
-        EXPECT_NE(nullptr, wifi_chip.get());
-
-        std::shared_ptr<IWifiStaIface> wifi_sta_iface = getWifiStaIface(getInstanceName());
-        EXPECT_NE(nullptr, wifi_sta_iface.get());
-
-        std::shared_ptr<IWifiRttController> rtt_controller;
-        EXPECT_TRUE(wifi_chip->createRttController(wifi_sta_iface, &rtt_controller).isOk());
-        EXPECT_NE(nullptr, rtt_controller.get());
-        return rtt_controller;
-    }
-
-    std::shared_ptr<IWifiRttController> wifi_rtt_controller_;
-
-  private:
-    const char* getInstanceName() { return GetParam().c_str(); }
-};
-
-class WifiRttControllerEventCallback : public BnWifiRttControllerEventCallback {
-  public:
-    WifiRttControllerEventCallback() = default;
-
-    ::ndk::ScopedAStatus onResults(int /* cmdId */,
-                                   const std::vector<RttResult>& /* results */) override {
-        return ndk::ScopedAStatus::ok();
-    }
-};
-
-/*
- * RegisterEventCallback
- *
- * Note: it is not feasible to test the invocation of the callback function,
- * since events are triggered internally in the HAL implementation and cannot be
- * triggered from the test case.
- */
-TEST_P(WifiRttControllerAidlTest, RegisterEventCallback) {
-    std::shared_ptr<WifiRttControllerEventCallback> callback =
-            ndk::SharedRefBase::make<WifiRttControllerEventCallback>();
-    ASSERT_NE(nullptr, callback.get());
-    EXPECT_TRUE(wifi_rtt_controller_->registerEventCallback(callback).isOk());
-}
-
-/*
- * GetCapabilities
- */
-TEST_P(WifiRttControllerAidlTest, GetCapabilities) {
-    RttCapabilities caps = {};
-    EXPECT_TRUE(wifi_rtt_controller_->getCapabilities(&caps).isOk());
-}
-
-/*
- * GetResponderInfo
- */
-TEST_P(WifiRttControllerAidlTest, GetResponderInfo) {
-    RttResponder responder = {};
-    EXPECT_TRUE(wifi_rtt_controller_->getResponderInfo(&responder).isOk());
-}
-
-/*
- * EnableResponder
- */
-TEST_P(WifiRttControllerAidlTest, EnableResponder) {
-    int cmdId = 55;
-    WifiChannelInfo channelInfo;
-    channelInfo.width = WifiChannelWidthInMhz::WIDTH_80;
-    channelInfo.centerFreq = 5660;
-    channelInfo.centerFreq0 = 5660;
-    channelInfo.centerFreq1 = 0;
-
-    RttResponder responder = {};
-    EXPECT_TRUE(wifi_rtt_controller_->getResponderInfo(&responder).isOk());
-    EXPECT_TRUE(wifi_rtt_controller_->enableResponder(cmdId, channelInfo, 10, responder).isOk());
-}
-
-/*
- * Request2SidedRangeMeasurement
- * Tests the two sided ranging - 802.11mc FTM protocol.
- */
-TEST_P(WifiRttControllerAidlTest, Request2SidedRangeMeasurement) {
-    RttCapabilities caps = {};
-    EXPECT_TRUE(wifi_rtt_controller_->getCapabilities(&caps).isOk());
-    if (!caps.rttFtmSupported) {
-        GTEST_SKIP() << "Skipping two sided RTT since driver/fw does not support";
-    }
-
-    RttConfig config;
-    config.addr = {{0x00, 0x01, 0x02, 0x03, 0x04, 0x05}};
-    config.type = RttType::TWO_SIDED;
-    config.peer = RttPeerType::AP;
-    config.channel.width = WifiChannelWidthInMhz::WIDTH_80;
-    config.channel.centerFreq = 5180;
-    config.channel.centerFreq0 = 5210;
-    config.channel.centerFreq1 = 0;
-    config.bw = RttBw::BW_20MHZ;
-    config.preamble = RttPreamble::HT;
-    config.mustRequestLci = false;
-    config.mustRequestLcr = false;
-    config.burstPeriod = 0;
-    config.numBurst = 0;
-    config.numFramesPerBurst = 8;
-    config.numRetriesPerRttFrame = 0;
-    config.numRetriesPerFtmr = 0;
-    config.burstDuration = 9;
-
-    int cmdId = 55;
-    std::vector<RttConfig> configs = {config};
-    EXPECT_TRUE(wifi_rtt_controller_->rangeRequest(cmdId, configs).isOk());
-
-    // Sleep for 2 seconds to wait for driver/firmware to complete RTT.
-    sleep(2);
-}
-
-/*
- * RangeRequest
- */
-TEST_P(WifiRttControllerAidlTest, RangeRequest) {
-    RttCapabilities caps = {};
-    EXPECT_TRUE(wifi_rtt_controller_->getCapabilities(&caps).isOk());
-    if (!caps.rttOneSidedSupported) {
-        GTEST_SKIP() << "Skipping one sided RTT since driver/fw does not support";
-    }
-
-    // Get the highest supported preamble.
-    int preamble = 1;
-    int caps_preamble_support = static_cast<int>(caps.preambleSupport);
-    caps_preamble_support >>= 1;
-    while (caps_preamble_support != 0) {
-        caps_preamble_support >>= 1;
-        preamble <<= 1;
-    }
-
-    RttConfig config;
-    config.addr = {{0x00, 0x01, 0x02, 0x03, 0x04, 0x05}};
-    config.type = RttType::ONE_SIDED;
-    config.peer = RttPeerType::AP;
-    config.channel.width = WifiChannelWidthInMhz::WIDTH_80;
-    config.channel.centerFreq = 5765;
-    config.channel.centerFreq0 = 5775;
-    config.channel.centerFreq1 = 0;
-    config.bw = RttBw::BW_80MHZ;
-    config.preamble = static_cast<RttPreamble>(preamble);
-    config.mustRequestLci = false;
-    config.mustRequestLcr = false;
-    config.burstPeriod = 0;
-    config.numBurst = 0;
-    config.numFramesPerBurst = 8;
-    config.numRetriesPerRttFrame = 3;
-    config.numRetriesPerFtmr = 3;
-    config.burstDuration = 9;
-
-    int cmdId = 55;
-    std::vector<RttConfig> configs = {config};
-    EXPECT_TRUE(wifi_rtt_controller_->rangeRequest(cmdId, configs).isOk());
-
-    // Sleep for 2 seconds to wait for driver/firmware to complete RTT.
-    sleep(2);
-}
-
-GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiRttControllerAidlTest);
-INSTANTIATE_TEST_SUITE_P(WifiTest, WifiRttControllerAidlTest,
-                         testing::ValuesIn(android::getAidlHalInstanceNames(IWifi::descriptor)),
-                         android::PrintInstanceNameToString);
-
-int main(int argc, char** argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-    android::ProcessState::self()->setThreadPoolMaxThreadCount(1);
-    android::ProcessState::self()->startThreadPool();
-    return RUN_ALL_TESTS();
-}
diff --git a/wifi/aidl/vts/functional/wifi_sta_iface_aidl_test.cpp b/wifi/aidl/vts/functional/wifi_sta_iface_aidl_test.cpp
deleted file mode 100644
index ef7e274..0000000
--- a/wifi/aidl/vts/functional/wifi_sta_iface_aidl_test.cpp
+++ /dev/null
@@ -1,282 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Staache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <vector>
-
-#include <VtsCoreUtil.h>
-#include <aidl/Gtest.h>
-#include <aidl/Vintf.h>
-#include <aidl/android/hardware/wifi/BnWifi.h>
-#include <android/binder_manager.h>
-#include <android/binder_status.h>
-#include <binder/IServiceManager.h>
-#include <binder/ProcessState.h>
-
-#include "wifi_aidl_test_utils.h"
-
-using aidl::android::hardware::wifi::IWifi;
-using aidl::android::hardware::wifi::IWifiStaIface;
-using aidl::android::hardware::wifi::MacAddress;
-using aidl::android::hardware::wifi::Ssid;
-using aidl::android::hardware::wifi::StaApfPacketFilterCapabilities;
-using aidl::android::hardware::wifi::StaBackgroundScanCapabilities;
-using aidl::android::hardware::wifi::StaLinkLayerStats;
-using aidl::android::hardware::wifi::StaRoamingCapabilities;
-using aidl::android::hardware::wifi::StaRoamingConfig;
-using aidl::android::hardware::wifi::StaRoamingState;
-using aidl::android::hardware::wifi::WifiBand;
-using aidl::android::hardware::wifi::WifiDebugRxPacketFateReport;
-using aidl::android::hardware::wifi::WifiDebugTxPacketFateReport;
-using aidl::android::hardware::wifi::WifiStatusCode;
-
-class WifiStaIfaceAidlTest : public testing::TestWithParam<std::string> {
-  public:
-    void SetUp() override {
-        stopWifiService(getInstanceName());
-        wifi_sta_iface_ = getWifiStaIface(getInstanceName());
-        ASSERT_NE(nullptr, wifi_sta_iface_.get());
-    }
-
-    void TearDown() override { stopWifiService(getInstanceName()); }
-
-  protected:
-    bool isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask expected) {
-        IWifiStaIface::StaIfaceCapabilityMask caps = {};
-        EXPECT_TRUE(wifi_sta_iface_->getCapabilities(&caps).isOk());
-        return static_cast<uint32_t>(caps) & static_cast<uint32_t>(expected);
-    }
-
-    ndk::ScopedAStatus createStaIface(std::shared_ptr<IWifiStaIface>* sta_iface) {
-        std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(getInstanceName());
-        EXPECT_NE(nullptr, wifi_chip.get());
-        return wifi_chip->createStaIface(sta_iface);
-    }
-
-    std::shared_ptr<IWifiStaIface> wifi_sta_iface_;
-
-  private:
-    const char* getInstanceName() { return GetParam().c_str(); }
-};
-
-/*
- * GetFactoryMacAddress
- * Ensures that calls to getFactoryMacAddress will retrieve a non-zero MAC.
- */
-TEST_P(WifiStaIfaceAidlTest, GetFactoryMacAddress) {
-    std::array<uint8_t, 6> mac;
-    EXPECT_TRUE(wifi_sta_iface_->getFactoryMacAddress(&mac).isOk());
-    std::array<uint8_t, 6> all_zero_mac = {0, 0, 0, 0, 0, 0};
-    EXPECT_NE(mac, all_zero_mac);
-}
-
-/*
- * GetCapabilities
- */
-TEST_P(WifiStaIfaceAidlTest, GetCapabilities) {
-    IWifiStaIface::StaIfaceCapabilityMask caps = {};
-    EXPECT_TRUE(wifi_sta_iface_->getCapabilities(&caps).isOk());
-    EXPECT_NE(static_cast<int32_t>(caps), 0);
-}
-
-/*
- * GetApfPacketFilterCapabilities
- */
-TEST_P(WifiStaIfaceAidlTest, GetApfPacketFilterCapabilities) {
-    if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::APF)) {
-        GTEST_SKIP() << "APF packet filter capabilities are not supported.";
-    }
-    StaApfPacketFilterCapabilities apf_caps = {};
-    EXPECT_TRUE(wifi_sta_iface_->getApfPacketFilterCapabilities(&apf_caps).isOk());
-}
-
-/*
- * GetBackgroundScanCapabilities
- */
-TEST_P(WifiStaIfaceAidlTest, GetBackgroundScanCapabilities) {
-    if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::BACKGROUND_SCAN)) {
-        GTEST_SKIP() << "Background scan capabilities are not supported.";
-    }
-    StaBackgroundScanCapabilities caps = {};
-    EXPECT_TRUE(wifi_sta_iface_->getBackgroundScanCapabilities(&caps).isOk());
-}
-
-/*
- * GetValidFrequenciesForBand
- * Ensures that we can retrieve valid frequencies for the 2.4 GHz band.
- */
-TEST_P(WifiStaIfaceAidlTest, GetValidFrequenciesForBand) {
-    std::vector<int> freqs;
-    EXPECT_TRUE(wifi_sta_iface_->getValidFrequenciesForBand(WifiBand::BAND_24GHZ, &freqs).isOk());
-    EXPECT_NE(freqs.size(), 0);
-}
-
-/*
- * GetLinkLayerStats
- * Ensures that calls to getLinkLayerStats will retrieve a non-empty
- * StaLinkLayerStats after link layer stats collection is enabled.
- */
-TEST_P(WifiStaIfaceAidlTest, GetLinkLayerStats) {
-    if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::LINK_LAYER_STATS)) {
-        GTEST_SKIP() << "Skipping this test since link layer stats are not supported.";
-    }
-
-    // Enable link layer stats collection.
-    EXPECT_TRUE(wifi_sta_iface_->enableLinkLayerStatsCollection(true).isOk());
-
-    // Retrieve link layer stats.
-    StaLinkLayerStats link_layer_stats = {};
-    EXPECT_TRUE(wifi_sta_iface_->getLinkLayerStats(&link_layer_stats).isOk());
-    EXPECT_GT(link_layer_stats.timeStampInMs, 0);
-
-    // Try to create a 2nd iface. If successful, it should fill the duty cycle field.
-    std::shared_ptr<IWifiStaIface> iface;
-    auto status = createStaIface(&iface);
-    if (status.isOk()) {
-        EXPECT_GT(link_layer_stats.iface.timeSliceDutyCycleInPercent, 0);
-    }
-
-    // Disable link layer stats collection.
-    EXPECT_TRUE(wifi_sta_iface_->disableLinkLayerStatsCollection().isOk());
-}
-
-/*
- * SetMacAddress
- * Ensures that calls to setMacAddress will return successfully.
- */
-TEST_P(WifiStaIfaceAidlTest, SetMacAddress) {
-    std::array<uint8_t, 6> mac = {0x12, 0x22, 0x33, 0x52, 0x10, 0x41};
-    EXPECT_TRUE(wifi_sta_iface_->setMacAddress(mac).isOk());
-}
-
-/*
- * SetScanMode
- */
-TEST_P(WifiStaIfaceAidlTest, SetScanMode) {
-    auto status = wifi_sta_iface_->setScanMode(true);
-    EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-
-    status = wifi_sta_iface_->setScanMode(false);
-    EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
-}
-
-/*
- * LinkLayerStatsCollection
- */
-TEST_P(WifiStaIfaceAidlTest, LinkLayerStatsCollection) {
-    if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::LINK_LAYER_STATS)) {
-        GTEST_SKIP() << "Link layer stats collection is not supported.";
-    }
-
-    // Enable link layer stats collection.
-    EXPECT_TRUE(wifi_sta_iface_->enableLinkLayerStatsCollection(true).isOk());
-
-    // Retrieve link layer stats.
-    StaLinkLayerStats link_layer_stats = {};
-    EXPECT_TRUE(wifi_sta_iface_->getLinkLayerStats(&link_layer_stats).isOk());
-
-    // Disable link layer stats collection.
-    EXPECT_TRUE(wifi_sta_iface_->disableLinkLayerStatsCollection().isOk());
-}
-
-/*
- * RSSIMonitoring
- * Ensures that calls to startRssiMonitoring and stopRssiMonitoring will fail
- * if the device is not connected to an AP.
- */
-TEST_P(WifiStaIfaceAidlTest, RSSIMonitoring) {
-    if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::RSSI_MONITOR)) {
-        GTEST_SKIP() << "RSSI monitoring is not supported.";
-    }
-
-    const int cmd = 1;
-    const int maxRssi = -50;
-    const int minRssi = -90;
-    // Expected to fail because device is not connected to an AP.
-    EXPECT_FALSE(wifi_sta_iface_->startRssiMonitoring(cmd, maxRssi, minRssi).isOk());
-    EXPECT_FALSE(wifi_sta_iface_->stopRssiMonitoring(cmd).isOk());
-}
-
-/*
- * RoamingControl
- */
-TEST_P(WifiStaIfaceAidlTest, RoamingControl) {
-    if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::CONTROL_ROAMING)) {
-        GTEST_SKIP() << "Roaming control is not supported.";
-    }
-
-    // Retrieve roaming capabilities.
-    StaRoamingCapabilities caps = {};
-    EXPECT_TRUE(wifi_sta_iface_->getRoamingCapabilities(&caps).isOk());
-
-    // Set up roaming configuration based on roaming capabilities.
-    StaRoamingConfig roaming_config = {};
-    if (caps.maxBlocklistSize > 0) {
-        MacAddress block_list_entry;
-        block_list_entry.data = std::array<uint8_t, 6>{{0x11, 0x22, 0x33, 0x44, 0x55, 0x66}};
-        roaming_config.bssidBlocklist = {block_list_entry};
-    }
-    if (caps.maxAllowlistSize > 0) {
-        Ssid allow_list_entry = {};
-        allow_list_entry.data = std::array<uint8_t, 32>{{0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC}};
-        roaming_config.ssidAllowlist = {allow_list_entry};
-    }
-
-    // Configure roaming.
-    EXPECT_TRUE(wifi_sta_iface_->configureRoaming(roaming_config).isOk());
-
-    // Enable roaming.
-    EXPECT_TRUE(wifi_sta_iface_->setRoamingState(StaRoamingState::ENABLED).isOk());
-}
-
-/*
- * EnableNDOffload
- */
-TEST_P(WifiStaIfaceAidlTest, EnableNDOffload) {
-    if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::ND_OFFLOAD)) {
-        GTEST_SKIP() << "ND offload is not supported.";
-    }
-    EXPECT_TRUE(wifi_sta_iface_->enableNdOffload(true).isOk());
-}
-
-/*
- * PacketFateMonitoring
- */
-TEST_P(WifiStaIfaceAidlTest, PacketFateMonitoring) {
-    if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::DEBUG_PACKET_FATE)) {
-        GTEST_SKIP() << "Packet fate monitoring is not supported.";
-    }
-
-    // Start packet fate monitoring.
-    EXPECT_TRUE(wifi_sta_iface_->startDebugPacketFateMonitoring().isOk());
-
-    // Retrieve packets.
-    std::vector<WifiDebugRxPacketFateReport> rx_reports;
-    std::vector<WifiDebugTxPacketFateReport> tx_reports;
-    EXPECT_TRUE(wifi_sta_iface_->getDebugRxPacketFates(&rx_reports).isOk());
-    EXPECT_TRUE(wifi_sta_iface_->getDebugTxPacketFates(&tx_reports).isOk());
-}
-
-GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiStaIfaceAidlTest);
-INSTANTIATE_TEST_SUITE_P(WifiTest, WifiStaIfaceAidlTest,
-                         testing::ValuesIn(android::getAidlHalInstanceNames(IWifi::descriptor)),
-                         android::PrintInstanceNameToString);
-
-int main(int argc, char** argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-    android::ProcessState::self()->setThreadPoolMaxThreadCount(1);
-    android::ProcessState::self()->startThreadPool();
-    return RUN_ALL_TESTS();
-}
diff --git a/wifi/apex/Android.bp b/wifi/apex/Android.bp
index e1fefb9..0afb96b 100644
--- a/wifi/apex/Android.bp
+++ b/wifi/apex/Android.bp
@@ -15,7 +15,7 @@
 
 genrule {
     name: "gen-android.hardware.wifi.rc",
-    srcs: [":default-android.hardware.wifi-service.rc"],
+    srcs: [":default-android.hardware.wifi@1.0-service.rc"],
     out: ["com.android.hardware.wifi-service.rc"],
     cmd: "sed -e 's@/vendor/bin/@/apex/com.android.hardware.wifi/bin/@' $(in) > $(out)",
 }
@@ -28,7 +28,7 @@
 
 prebuilt_etc {
     name: "com.android.hardware.wifi.xml",
-    src: ":default-android.hardware.wifi-service.xml",
+    src: ":default-android.hardware.wifi@1.0-service.xml",
     installable: false,
 }
 
@@ -43,13 +43,13 @@
     updatable: false,
     soc_specific: true,
     binaries: [
-        "android.hardware.wifi-service",
+        "android.hardware.wifi@1.0-service",
     ],
     prebuilts: [
         "com.android.hardware.wifi.rc",
         "com.android.hardware.wifi.xml",
     ],
     overrides: [
-        "android.hardware.wifi-service",
+        "android.hardware.wifi@1.0-service",
     ],
 }
diff --git a/wifi/apex/file_contexts b/wifi/apex/file_contexts
index 6368729..812d51d 100644
--- a/wifi/apex/file_contexts
+++ b/wifi/apex/file_contexts
@@ -1,3 +1,3 @@
 (/.*)? 								u:object_r:vendor_file:s0
-/bin/hw/android\.hardware\.wifi-service			u:object_r:hal_wifi_default_exec:s0
+/bin/hw/android\.hardware\.wifi@1.0-service			u:object_r:hal_wifi_default_exec:s0