diff --git a/wifi/aidl/default/aidl_struct_util.cpp b/wifi/aidl/default/aidl_struct_util.cpp
index 4acdd2f..7bc2eeb 100644
--- a/wifi/aidl/default/aidl_struct_util.cpp
+++ b/wifi/aidl/default/aidl_struct_util.cpp
@@ -41,68 +41,67 @@
     return std::vector<int32_t>(in.begin(), in.end());
 }
 
-IWifiChip::ChipCapabilityMask convertLegacyFeatureToAidlChipCapability(uint64_t feature) {
+IWifiChip::FeatureSetMask convertLegacyChipFeatureToAidl(uint64_t feature) {
     switch (feature) {
         case WIFI_FEATURE_SET_TX_POWER_LIMIT:
-            return IWifiChip::ChipCapabilityMask::SET_TX_POWER_LIMIT;
+            return IWifiChip::FeatureSetMask::SET_TX_POWER_LIMIT;
         case WIFI_FEATURE_USE_BODY_HEAD_SAR:
-            return IWifiChip::ChipCapabilityMask::USE_BODY_HEAD_SAR;
+            return IWifiChip::FeatureSetMask::USE_BODY_HEAD_SAR;
         case WIFI_FEATURE_D2D_RTT:
-            return IWifiChip::ChipCapabilityMask::D2D_RTT;
+            return IWifiChip::FeatureSetMask::D2D_RTT;
         case WIFI_FEATURE_D2AP_RTT:
-            return IWifiChip::ChipCapabilityMask::D2AP_RTT;
+            return IWifiChip::FeatureSetMask::D2AP_RTT;
         case WIFI_FEATURE_INFRA_60G:
-            return IWifiChip::ChipCapabilityMask::WIGIG;
+            return IWifiChip::FeatureSetMask::WIGIG;
         case WIFI_FEATURE_SET_LATENCY_MODE:
-            return IWifiChip::ChipCapabilityMask::SET_LATENCY_MODE;
+            return IWifiChip::FeatureSetMask::SET_LATENCY_MODE;
         case WIFI_FEATURE_P2P_RAND_MAC:
-            return IWifiChip::ChipCapabilityMask::P2P_RAND_MAC;
+            return IWifiChip::FeatureSetMask::P2P_RAND_MAC;
         case WIFI_FEATURE_AFC_CHANNEL:
-            return IWifiChip::ChipCapabilityMask::SET_AFC_CHANNEL_ALLOWANCE;
+            return IWifiChip::FeatureSetMask::SET_AFC_CHANNEL_ALLOWANCE;
     };
     CHECK(false) << "Unknown legacy feature: " << feature;
     return {};
 }
 
-IWifiStaIface::StaIfaceCapabilityMask convertLegacyFeatureToAidlStaIfaceCapability(
-        uint64_t feature) {
+IWifiStaIface::FeatureSetMask convertLegacyStaIfaceFeatureToAidl(uint64_t feature) {
     switch (feature) {
         case WIFI_FEATURE_GSCAN:
-            return IWifiStaIface::StaIfaceCapabilityMask::BACKGROUND_SCAN;
+            return IWifiStaIface::FeatureSetMask::BACKGROUND_SCAN;
         case WIFI_FEATURE_LINK_LAYER_STATS:
-            return IWifiStaIface::StaIfaceCapabilityMask::LINK_LAYER_STATS;
+            return IWifiStaIface::FeatureSetMask::LINK_LAYER_STATS;
         case WIFI_FEATURE_RSSI_MONITOR:
-            return IWifiStaIface::StaIfaceCapabilityMask::RSSI_MONITOR;
+            return IWifiStaIface::FeatureSetMask::RSSI_MONITOR;
         case WIFI_FEATURE_CONTROL_ROAMING:
-            return IWifiStaIface::StaIfaceCapabilityMask::CONTROL_ROAMING;
+            return IWifiStaIface::FeatureSetMask::CONTROL_ROAMING;
         case WIFI_FEATURE_IE_WHITELIST:
-            return IWifiStaIface::StaIfaceCapabilityMask::PROBE_IE_ALLOWLIST;
+            return IWifiStaIface::FeatureSetMask::PROBE_IE_ALLOWLIST;
         case WIFI_FEATURE_SCAN_RAND:
-            return IWifiStaIface::StaIfaceCapabilityMask::SCAN_RAND;
+            return IWifiStaIface::FeatureSetMask::SCAN_RAND;
         case WIFI_FEATURE_INFRA_5G:
-            return IWifiStaIface::StaIfaceCapabilityMask::STA_5G;
+            return IWifiStaIface::FeatureSetMask::STA_5G;
         case WIFI_FEATURE_HOTSPOT:
-            return IWifiStaIface::StaIfaceCapabilityMask::HOTSPOT;
+            return IWifiStaIface::FeatureSetMask::HOTSPOT;
         case WIFI_FEATURE_PNO:
-            return IWifiStaIface::StaIfaceCapabilityMask::PNO;
+            return IWifiStaIface::FeatureSetMask::PNO;
         case WIFI_FEATURE_TDLS:
-            return IWifiStaIface::StaIfaceCapabilityMask::TDLS;
+            return IWifiStaIface::FeatureSetMask::TDLS;
         case WIFI_FEATURE_TDLS_OFFCHANNEL:
-            return IWifiStaIface::StaIfaceCapabilityMask::TDLS_OFFCHANNEL;
+            return IWifiStaIface::FeatureSetMask::TDLS_OFFCHANNEL;
         case WIFI_FEATURE_CONFIG_NDO:
-            return IWifiStaIface::StaIfaceCapabilityMask::ND_OFFLOAD;
+            return IWifiStaIface::FeatureSetMask::ND_OFFLOAD;
         case WIFI_FEATURE_MKEEP_ALIVE:
-            return IWifiStaIface::StaIfaceCapabilityMask::KEEP_ALIVE;
+            return IWifiStaIface::FeatureSetMask::KEEP_ALIVE;
     };
     CHECK(false) << "Unknown legacy feature: " << feature;
     return {};
 }
 
-bool convertLegacyFeaturesToAidlChipCapabilities(uint64_t legacy_feature_set, uint32_t* aidl_caps) {
-    if (!aidl_caps) {
+bool convertLegacyChipFeaturesToAidl(uint64_t legacy_feature_set, uint32_t* aidl_feature_set) {
+    if (!aidl_feature_set) {
         return false;
     }
-    *aidl_caps = {};
+    *aidl_feature_set = 0;
     std::vector<uint64_t> features = {WIFI_FEATURE_SET_TX_POWER_LIMIT,
                                       WIFI_FEATURE_USE_BODY_HEAD_SAR,
                                       WIFI_FEATURE_D2D_RTT,
@@ -113,7 +112,7 @@
                                       WIFI_FEATURE_AFC_CHANNEL};
     for (const auto feature : features) {
         if (feature & legacy_feature_set) {
-            *aidl_caps |= static_cast<uint32_t>(convertLegacyFeatureToAidlChipCapability(feature));
+            *aidl_feature_set |= static_cast<uint32_t>(convertLegacyChipFeatureToAidl(feature));
         }
     }
 
@@ -449,24 +448,23 @@
     return true;
 }
 
-bool convertLegacyFeaturesToAidlStaCapabilities(uint64_t legacy_feature_set, uint32_t* aidl_caps) {
-    if (!aidl_caps) {
+bool convertLegacyStaIfaceFeaturesToAidl(uint64_t legacy_feature_set, uint32_t* aidl_feature_set) {
+    if (!aidl_feature_set) {
         return false;
     }
-    *aidl_caps = {};
+    *aidl_feature_set = 0;
     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));
+            *aidl_feature_set |= static_cast<uint32_t>(convertLegacyStaIfaceFeatureToAidl(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);
+    *aidl_feature_set |= static_cast<uint32_t>(IWifiStaIface::FeatureSetMask::APF);
     return true;
 }
 
diff --git a/wifi/aidl/default/aidl_struct_util.h b/wifi/aidl/default/aidl_struct_util.h
index 9a13672..e4ff963 100644
--- a/wifi/aidl/default/aidl_struct_util.h
+++ b/wifi/aidl/default/aidl_struct_util.h
@@ -40,7 +40,7 @@
 namespace aidl_struct_util {
 
 // Chip conversion methods.
-bool convertLegacyFeaturesToAidlChipCapabilities(uint64_t legacy_feature_set, uint32_t* aidl_caps);
+bool convertLegacyChipFeaturesToAidl(uint64_t legacy_feature_set, uint32_t* aidl_feature_set);
 bool convertLegacyDebugRingBufferStatusToAidl(
         const legacy_hal::wifi_ring_buffer_status& legacy_status,
         WifiDebugRingBufferStatus* aidl_status);
@@ -74,7 +74,7 @@
         legacy_hal::wifi_iface_concurrency_matrix& legacy_matrix, IWifiChip::ChipMode* chip_mode);
 
 // STA iface conversion methods.
-bool convertLegacyFeaturesToAidlStaCapabilities(uint64_t legacy_feature_set, uint32_t* aidl_caps);
+bool convertLegacyStaIfaceFeaturesToAidl(uint64_t legacy_feature_set, uint32_t* aidl_feature_set);
 bool convertLegacyApfCapabilitiesToAidl(const legacy_hal::PacketFilterCapabilities& legacy_caps,
                                         StaApfPacketFilterCapabilities* aidl_caps);
 bool convertLegacyGscanCapabilitiesToAidl(const legacy_hal::wifi_gscan_capabilities& legacy_caps,
diff --git a/wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp b/wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp
index 4bd77ac..5c334f8 100644
--- a/wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp
+++ b/wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp
@@ -658,16 +658,16 @@
 }
 
 TEST_F(AidlStructUtilTest, CanConvertLegacyFeaturesToAidl) {
-    using AidlChipCaps = IWifiChip::ChipCapabilityMask;
+    using AidlChipCaps = IWifiChip::FeatureSetMask;
 
-    uint32_t aidl_caps;
+    uint32_t aidl_features;
     uint32_t legacy_feature_set = WIFI_FEATURE_D2D_RTT | WIFI_FEATURE_SET_LATENCY_MODE;
 
-    ASSERT_TRUE(aidl_struct_util::convertLegacyFeaturesToAidlChipCapabilities(legacy_feature_set,
-                                                                              &aidl_caps));
+    ASSERT_TRUE(
+            aidl_struct_util::convertLegacyChipFeaturesToAidl(legacy_feature_set, &aidl_features));
 
     EXPECT_EQ((uint32_t)AidlChipCaps::D2D_RTT | (uint32_t)AidlChipCaps::SET_LATENCY_MODE,
-              aidl_caps);
+              aidl_features);
 }
 
 void insertRadioCombination(legacy_hal::wifi_radio_combination* dst_radio_combination_ptr,
diff --git a/wifi/aidl/default/wifi_chip.cpp b/wifi/aidl/default/wifi_chip.cpp
index dd24e6b..3b2dba2 100644
--- a/wifi/aidl/default/wifi_chip.cpp
+++ b/wifi/aidl/default/wifi_chip.cpp
@@ -455,9 +455,9 @@
                            &WifiChip::registerEventCallbackInternal, event_callback);
 }
 
-ndk::ScopedAStatus WifiChip::getCapabilities(int32_t* _aidl_return) {
+ndk::ScopedAStatus WifiChip::getFeatureSet(int32_t* _aidl_return) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
-                           &WifiChip::getCapabilitiesInternal, _aidl_return);
+                           &WifiChip::getFeatureSetInternal, _aidl_return);
 }
 
 ndk::ScopedAStatus WifiChip::getAvailableModes(std::vector<IWifiChip::ChipMode>* _aidl_return) {
@@ -786,7 +786,7 @@
     return ndk::ScopedAStatus::ok();
 }
 
-std::pair<int32_t, ndk::ScopedAStatus> WifiChip::getCapabilitiesInternal() {
+std::pair<int32_t, ndk::ScopedAStatus> WifiChip::getFeatureSetInternal() {
     legacy_hal::wifi_error legacy_status;
     uint64_t legacy_feature_set;
     uint32_t legacy_logger_feature_set;
@@ -802,12 +802,11 @@
         // 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,
-                                                                       &aidl_caps)) {
+    uint32_t aidl_feature_set;
+    if (!aidl_struct_util::convertLegacyChipFeaturesToAidl(legacy_feature_set, &aidl_feature_set)) {
         return {0, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
     }
-    return {aidl_caps, ndk::ScopedAStatus::ok()};
+    return {aidl_feature_set, ndk::ScopedAStatus::ok()};
 }
 
 std::pair<std::vector<IWifiChip::ChipMode>, ndk::ScopedAStatus>
diff --git a/wifi/aidl/default/wifi_chip.h b/wifi/aidl/default/wifi_chip.h
index c5dcee7..6d2a59e 100644
--- a/wifi/aidl/default/wifi_chip.h
+++ b/wifi/aidl/default/wifi_chip.h
@@ -85,7 +85,7 @@
     ndk::ScopedAStatus getId(int32_t* _aidl_return) override;
     ndk::ScopedAStatus registerEventCallback(
             const std::shared_ptr<IWifiChipEventCallback>& in_callback) override;
-    ndk::ScopedAStatus getCapabilities(int32_t* _aidl_return) override;
+    ndk::ScopedAStatus getFeatureSet(int32_t* _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;
@@ -162,7 +162,7 @@
     std::pair<int32_t, ndk::ScopedAStatus> getIdInternal();
     ndk::ScopedAStatus registerEventCallbackInternal(
             const std::shared_ptr<IWifiChipEventCallback>& event_callback);
-    std::pair<int32_t, ndk::ScopedAStatus> getCapabilitiesInternal();
+    std::pair<int32_t, ndk::ScopedAStatus> getFeatureSetInternal();
     std::pair<std::vector<IWifiChip::ChipMode>, ndk::ScopedAStatus> getAvailableModesInternal();
     ndk::ScopedAStatus configureChipInternal(std::unique_lock<std::recursive_mutex>* lock,
                                              int32_t mode_id);
diff --git a/wifi/aidl/default/wifi_sta_iface.cpp b/wifi/aidl/default/wifi_sta_iface.cpp
index eceeeb5..73a8c7a 100644
--- a/wifi/aidl/default/wifi_sta_iface.cpp
+++ b/wifi/aidl/default/wifi_sta_iface.cpp
@@ -82,9 +82,9 @@
                            &WifiStaIface::registerEventCallbackInternal, in_callback);
 }
 
-ndk::ScopedAStatus WifiStaIface::getCapabilities(int32_t* _aidl_return) {
+ndk::ScopedAStatus WifiStaIface::getFeatureSet(int32_t* _aidl_return) {
     return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                           &WifiStaIface::getCapabilitiesInternal, _aidl_return);
+                           &WifiStaIface::getFeatureSetInternal, _aidl_return);
 }
 
 ndk::ScopedAStatus WifiStaIface::getApfPacketFilterCapabilities(
@@ -238,7 +238,7 @@
     return ndk::ScopedAStatus::ok();
 }
 
-std::pair<int32_t, ndk::ScopedAStatus> WifiStaIface::getCapabilitiesInternal() {
+std::pair<int32_t, ndk::ScopedAStatus> WifiStaIface::getFeatureSetInternal() {
     legacy_hal::wifi_error legacy_status;
     uint64_t legacy_feature_set;
     std::tie(legacy_status, legacy_feature_set) =
@@ -246,12 +246,12 @@
     if (legacy_status != legacy_hal::WIFI_SUCCESS) {
         return {0, createWifiStatusFromLegacyError(legacy_status)};
     }
-    uint32_t aidl_caps;
-    if (!aidl_struct_util::convertLegacyFeaturesToAidlStaCapabilities(legacy_feature_set,
-                                                                      &aidl_caps)) {
+    uint32_t aidl_feature_set;
+    if (!aidl_struct_util::convertLegacyStaIfaceFeaturesToAidl(legacy_feature_set,
+                                                               &aidl_feature_set)) {
         return {0, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
     }
-    return {aidl_caps, ndk::ScopedAStatus::ok()};
+    return {aidl_feature_set, ndk::ScopedAStatus::ok()};
 }
 
 std::pair<StaApfPacketFilterCapabilities, ndk::ScopedAStatus>
diff --git a/wifi/aidl/default/wifi_sta_iface.h b/wifi/aidl/default/wifi_sta_iface.h
index 0831e16..8db424b 100644
--- a/wifi/aidl/default/wifi_sta_iface.h
+++ b/wifi/aidl/default/wifi_sta_iface.h
@@ -54,7 +54,7 @@
     ndk::ScopedAStatus getName(std::string* _aidl_return) override;
     ndk::ScopedAStatus registerEventCallback(
             const std::shared_ptr<IWifiStaIfaceEventCallback>& in_callback) override;
-    ndk::ScopedAStatus getCapabilities(int32_t* _aidl_return) override;
+    ndk::ScopedAStatus getFeatureSet(int32_t* _aidl_return) override;
     ndk::ScopedAStatus getApfPacketFilterCapabilities(
             StaApfPacketFilterCapabilities* _aidl_return) override;
     ndk::ScopedAStatus installApfPacketFilter(const std::vector<uint8_t>& in_program) override;
@@ -98,7 +98,7 @@
     std::pair<std::string, ndk::ScopedAStatus> getNameInternal();
     ndk::ScopedAStatus registerEventCallbackInternal(
             const std::shared_ptr<IWifiStaIfaceEventCallback>& callback);
-    std::pair<int32_t, ndk::ScopedAStatus> getCapabilitiesInternal();
+    std::pair<int32_t, ndk::ScopedAStatus> getFeatureSetInternal();
     std::pair<StaApfPacketFilterCapabilities, ndk::ScopedAStatus>
     getApfPacketFilterCapabilitiesInternal();
     ndk::ScopedAStatus installApfPacketFilterInternal(const std::vector<uint8_t>& program);