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

Commit 2f86249f authored by Gabriel Biren's avatar Gabriel Biren
Browse files

Rename getCapabilities to getFeatureSet 

in the Vendor HAL implementation.

Bug: 267819850
Test: Run gTest suite
Change-Id: Id21f3edde0b01636d0a994cc8b7b1d434bacaa04
parent 2a391a09

wifi/aidl/default/aidl_struct_util.cpp

+32 −34
Original line number Diff line number Diff line
@@ -41,68 +41,67 @@ inline std::vector<int32_t> uintToIntVec(const std::vector<uint32_t>& in) { 
    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 @@ bool convertLegacyFeaturesToAidlChipCapabilities(uint64_t legacy_feature_set, ui 
                                      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 @@ bool convertLegacyWifiMacInfosToAidl( 
    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;

}

wifi/aidl/default/aidl_struct_util.h

+2 −2
Original line number Diff line number Diff line
@@ -40,7 +40,7 @@ namespace wifi { 
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 @@ bool convertLegacyIfaceCombinationsMatrixToChipMode( 
        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,

wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp

+5 −5
Original line number Diff line number Diff line
@@ -658,16 +658,16 @@ TEST_F(AidlStructUtilTest, canConvertLegacyLinkLayerStatsToAidl) { 
}



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,

wifi/aidl/default/wifi_chip.cpp

+6 −7
Original line number Diff line number Diff line
@@ -455,9 +455,9 @@ ndk::ScopedAStatus WifiChip::registerEventCallback( 
                           &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 @@ ndk::ScopedAStatus WifiChip::registerEventCallbackInternal( 
    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 @@ std::pair<int32_t, ndk::ScopedAStatus> WifiChip::getCapabilitiesInternal() { 
        // 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>

wifi/aidl/default/wifi_chip.h

+2 −2
Original line number Diff line number Diff line
@@ -85,7 +85,7 @@ class WifiChip : public BnWifiChip { 
    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 @@ class WifiChip : public BnWifiChip { 
    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);