Merge "Wifi: Add support to query and use driver advertised interface combination" into udc-dev (87bc929e) · Commits · e / os / android_hardware_interfaces

wifi/aidl/default/aidl_struct_util.cpp

+58 −0

Original line number	Diff line number	Diff line
		@@ -3300,6 +3300,64 @@ uint32_t convertAidlChannelCategoryToLegacy(uint32_t aidl_channel_category_mask)
		return channel_category_mask;
		}

		bool convertLegacyIfaceMaskToIfaceConcurrencyType(u32 mask,
		std::vector<IfaceConcurrencyType>* types) {
		if (!mask) return false;

		#ifndef BIT
		#define BIT(x) (1 << (x))
		#endif
		if (mask & BIT(WIFI_INTERFACE_TYPE_STA)) types->push_back(IfaceConcurrencyType::STA);
		if (mask & BIT(WIFI_INTERFACE_TYPE_AP)) types->push_back(IfaceConcurrencyType::AP);
		if (mask & BIT(WIFI_INTERFACE_TYPE_AP_BRIDGED))
		types->push_back(IfaceConcurrencyType::AP_BRIDGED);
		if (mask & BIT(WIFI_INTERFACE_TYPE_P2P)) types->push_back(IfaceConcurrencyType::P2P);
		if (mask & BIT(WIFI_INTERFACE_TYPE_NAN)) types->push_back(IfaceConcurrencyType::NAN_IFACE);

		return true;
		}

		bool convertLegacyIfaceCombinationsMatrixToChipMode(
		legacy_hal::wifi_iface_concurrency_matrix& legacy_matrix, IWifiChip::ChipMode* chip_mode) {
		if (!chip_mode) {
		LOG(ERROR) << "chip_mode is null";
		return false;
		}
		*chip_mode = {};

		int num_combinations = legacy_matrix.num_iface_combinations;
		std::vector<IWifiChip::ChipConcurrencyCombination> driver_Combinations_vec;
		if (!num_combinations) {
		LOG(ERROR) << "zero iface combinations";
		return false;
		}

		for (int i = 0; i < num_combinations; i++) {
		IWifiChip::ChipConcurrencyCombination chipComb;
		std::vector<IWifiChip::ChipConcurrencyCombinationLimit> limits;
		wifi_iface_combination* comb = &legacy_matrix.iface_combinations[i];
		if (!comb->num_iface_limits) continue;
		for (u32 j = 0; j < comb->num_iface_limits; j++) {
		IWifiChip::ChipConcurrencyCombinationLimit chipLimit;
		chipLimit.maxIfaces = comb->iface_limits[j].max_limit;
		std::vector<IfaceConcurrencyType> types;
		if (!convertLegacyIfaceMaskToIfaceConcurrencyType(comb->iface_limits[j].iface_mask,
		&types)) {
		LOG(ERROR) << "Failed to convert from iface_mask:"
		<< comb->iface_limits[j].iface_mask;
		return false;
		}
		chipLimit.types = types;
		limits.push_back(chipLimit);
		}
		chipComb.limits = limits;
		driver_Combinations_vec.push_back(chipComb);
		}

		chip_mode->availableCombinations = driver_Combinations_vec;
		return true;
		}

		} // namespace aidl_struct_util
		} // namespace wifi
		} // namespace hardware

wifi/aidl/default/aidl_struct_util.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -67,6 +67,8 @@ bool convertLegacyRadioCombinationsMatrixToAidl(
		WifiRadioCombinationMatrix* aidl_matrix);
		WifiBand convertLegacyMacBandToAidlWifiBand(uint32_t band);
		WifiAntennaMode convertLegacyAntennaConfigurationToAidl(uint32_t antenna_cfg);
		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);

wifi/aidl/default/wifi_chip.cpp

+31 −0

Original line number	Diff line number	Diff line
		@@ -377,6 +377,35 @@ WifiChip::WifiChip(int32_t chip_id, bool is_primary,
		debug_ring_buffer_cb_registered_(false),
		subsystemCallbackHandler_(handler) {
		setActiveWlanIfaceNameProperty(kNoActiveWlanIfaceNamePropertyValue);
		using_dynamic_iface_combination_ = false;
		}

		void WifiChip::retrieveDynamicIfaceCombination() {
		if (using_dynamic_iface_combination_) return;

		legacy_hal::wifi_iface_concurrency_matrix legacy_matrix;
		legacy_hal::wifi_error legacy_status;

		std::tie(legacy_status, legacy_matrix) =
		legacy_hal_.lock()->getSupportedIfaceConcurrencyMatrix();
		if (legacy_status != legacy_hal::WIFI_SUCCESS) {
		LOG(ERROR) << "Failed to get SupportedIfaceCombinations matrix from legacy HAL: "
		<< legacyErrorToString(legacy_status);
		return;
		}

		IWifiChip::ChipMode aidl_chip_mode;
		if (!aidl_struct_util::convertLegacyIfaceCombinationsMatrixToChipMode(legacy_matrix,
		&aidl_chip_mode)) {
		LOG(ERROR) << "Failed convertLegacyIfaceCombinationsMatrixToChipMode() ";
		return;
		}

		LOG(INFO) << "Reloading iface concurrency combination from driver";
		aidl_chip_mode.id = feature_flags::chip_mode_ids::kV3;
		modes_.clear();
		modes_.push_back(aidl_chip_mode);
		using_dynamic_iface_combination_ = true;
		}

		std::shared_ptr<WifiChip> WifiChip::create(
		@@ -1509,6 +1538,8 @@ ndk::ScopedAStatus WifiChip::handleChipConfiguration(
		version_info.first.firmwareDescription.c_str());
		property_set("vendor.wlan.driver.version", version_info.first.driverDescription.c_str());
		}
		// Get the driver supported interface combination.
		retrieveDynamicIfaceCombination();

		return ndk::ScopedAStatus::ok();
		}

wifi/aidl/default/wifi_chip.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -262,6 +262,7 @@ class WifiChip : public BnWifiChip {
		getSupportedRadioCombinationsMatrixInternal();
		std::pair<WifiChipCapabilities, ndk::ScopedAStatus> getWifiChipCapabilitiesInternal();
		ndk::ScopedAStatus setMloModeInternal(const ChipMloMode in_mode);
		void retrieveDynamicIfaceCombination();
		void setWeakPtr(std::weak_ptr<WifiChip> ptr);

		int32_t chip_id_;
		@@ -283,6 +284,7 @@ class WifiChip : public BnWifiChip {
		// registration mechanism. Use this to check if we have already
		// registered a callback.
		bool debug_ring_buffer_cb_registered_;
		bool using_dynamic_iface_combination_;
		aidl_callback_util::AidlCallbackHandler<IWifiChipEventCallback> event_cb_handler_;
		std::weak_ptr<WifiChip> weak_ptr_this_;

wifi/aidl/default/wifi_legacy_hal.cpp

+8 −0

Original line number	Diff line number	Diff line
		@@ -1885,6 +1885,14 @@ wifi_error WifiLegacyHal::setMloMode(wifi_mlo_mode mode) {
		return global_func_table_.wifi_set_mlo_mode(global_handle_, mode);
		}

		std::pair<wifi_error, wifi_iface_concurrency_matrix>
		WifiLegacyHal::getSupportedIfaceConcurrencyMatrix() {
		wifi_iface_concurrency_matrix iface_concurrency_matrix;
		wifi_error status = global_func_table_.wifi_get_supported_iface_concurrency_matrix(
		global_handle_, &iface_concurrency_matrix);
		return {status, iface_concurrency_matrix};
		}

		void WifiLegacyHal::invalidate() {
		global_handle_ = nullptr;
		iface_name_to_handle_.clear();