Merge "Add 11az secure ranging hal implementation" into main (33d9487c) · Commits · e / os / android_hardware_interfaces

wifi/aidl/default/aidl_struct_util.cpp

+267 −0

Original line number	Diff line number	Diff line
		@@ -2815,6 +2815,138 @@ bool convertAidlRttConfigToLegacyV3(const RttConfig& aidl_config,
		return true;
		}

		long convertLegacyAkmsToAidl(legacy_hal::wifi_rtt_akm akms) {
		long aidl_akms = Akm::NONE;
		if ((akms & legacy_hal::WPA_KEY_MGMT_PASN) != 0) {
		aidl_akms \|= Akm::PASN;
		}
		if ((akms & legacy_hal::WPA_KEY_MGMT_SAE) != 0) {
		aidl_akms \|= Akm::SAE;
		}
		if ((akms & legacy_hal::WPA_KEY_MGMT_EAP_FT_SHA256) != 0) {
		aidl_akms \|= Akm::FT_EAP_SHA256;
		}
		if ((akms & legacy_hal::WPA_KEY_MGMT_FT_PSK_SHA256) != 0) {
		aidl_akms \|= Akm::FT_PSK_SHA256;
		}
		if ((akms & legacy_hal::WPA_KEY_MGMT_EAP_FT_SHA384) != 0) {
		aidl_akms \|= Akm::FT_EAP_SHA384;
		}
		if ((akms & legacy_hal::WPA_KEY_MGMT_FT_PSK_SHA384) != 0) {
		aidl_akms \|= Akm::FT_PSK_SHA384;
		}
		if ((akms & legacy_hal::WPA_KEY_MGMT_EAP_FILS_SHA256) != 0) {
		aidl_akms \|= Akm::FILS_EAP_SHA256;
		}
		if ((akms & legacy_hal::WPA_KEY_MGMT_EAP_FILS_SHA384) != 0) {
		aidl_akms \|= Akm::FILS_EAP_SHA384;
		}
		return aidl_akms;
		}

		legacy_hal::wifi_rtt_akm convertAidlAkmToLegacy(long akm) {
		switch (akm) {
		case Akm::PASN:
		return legacy_hal::WPA_KEY_MGMT_PASN;
		case Akm::SAE:
		return legacy_hal::WPA_KEY_MGMT_SAE;
		case Akm::FT_EAP_SHA256:
		return legacy_hal::WPA_KEY_MGMT_EAP_FT_SHA256;
		case Akm::FT_PSK_SHA256:
		return legacy_hal::WPA_KEY_MGMT_FT_PSK_SHA256;
		case Akm::FT_EAP_SHA384:
		return legacy_hal::WPA_KEY_MGMT_EAP_FT_SHA384;
		case Akm::FT_PSK_SHA384:
		return legacy_hal::WPA_KEY_MGMT_FT_PSK_SHA384;
		case Akm::FILS_EAP_SHA256:
		return legacy_hal::WPA_KEY_MGMT_EAP_FILS_SHA256;
		case Akm::FILS_EAP_SHA384:
		return legacy_hal::WPA_KEY_MGMT_EAP_FILS_SHA384;
		default:
		return legacy_hal::WPA_KEY_MGMT_NONE;
		}
		}

		long convertLegacyCipherSuitesToAidl(legacy_hal::wifi_rtt_cipher_suite ciphers) {
		long aidl_ciphers = CipherSuite::NONE;
		if ((ciphers & legacy_hal::WPA_CIPHER_CCMP_128) != 0) {
		aidl_ciphers \|= CipherSuite::CCMP_128;
		}
		if ((ciphers & legacy_hal::WPA_CIPHER_CCMP_256) != 0) {
		aidl_ciphers \|= CipherSuite::CCMP_256;
		}
		if ((ciphers & legacy_hal::WPA_CIPHER_GCMP_128) != 0) {
		aidl_ciphers \|= CipherSuite::GCMP_128;
		}
		if ((ciphers & legacy_hal::WPA_CIPHER_GCMP_256) != 0) {
		aidl_ciphers \|= CipherSuite::GCMP_256;
		}
		return aidl_ciphers;
		}

		legacy_hal::wifi_rtt_cipher_suite convertAidlCipherSuiteToLegacy(long cipher) {
		switch (cipher) {
		case CipherSuite::CCMP_128:
		return WPA_CIPHER_CCMP_128;
		case CipherSuite::CCMP_256:
		return WPA_CIPHER_CCMP_256;
		case CipherSuite::GCMP_128:
		return WPA_CIPHER_GCMP_128;
		case CipherSuite::GCMP_256:
		return WPA_CIPHER_GCMP_256;
		default:
		return WPA_CIPHER_NONE;
		}
		}

		bool convertAidlRttConfigToLegacyV4(const RttConfig& aidl_config,
		legacy_hal::wifi_rtt_config_v4* legacy_config) {
		if (!legacy_config) {
		return false;
		}
		*legacy_config = {};
		if (!convertAidlRttConfigToLegacyV3(aidl_config, &(legacy_config->rtt_config))) {
		return false;
		}
		if (aidl_config.secureConfig.has_value()) {
		legacy_config->rtt_secure_config.enable_secure_he_ltf =
		aidl_config.secureConfig->enableSecureHeLtf;
		legacy_config->rtt_secure_config.enable_ranging_frame_protection =
		aidl_config.secureConfig->enableRangingFrameProtection;
		if (aidl_config.secureConfig->pasnComebackCookie.has_value() &&
		aidl_config.secureConfig->pasnComebackCookie->size() <= RTT_MAX_COOKIE_LEN) {
		legacy_config->rtt_secure_config.pasn_config.comeback_cookie_len =
		aidl_config.secureConfig->pasnComebackCookie->size();
		memcpy(legacy_config->rtt_secure_config.pasn_config.comeback_cookie,
		aidl_config.secureConfig->pasnComebackCookie->data(),
		aidl_config.secureConfig->pasnComebackCookie->size());
		}
		legacy_config->rtt_secure_config.pasn_config.base_akm =
		convertAidlAkmToLegacy(aidl_config.secureConfig->pasnConfig.baseAkm);
		legacy_config->rtt_secure_config.pasn_config.pairwise_cipher_suite =
		convertAidlCipherSuiteToLegacy(aidl_config.secureConfig->pasnConfig.cipherSuite);
		if (aidl_config.secureConfig->pasnConfig.passphrase.has_value() &&
		aidl_config.secureConfig->pasnConfig.passphrase->size() <=
		RTT_SECURITY_MAX_PASSPHRASE_LEN) {
		legacy_config->rtt_secure_config.pasn_config.passphrase_len =
		aidl_config.secureConfig->pasnConfig.passphrase->size();
		memcpy(legacy_config->rtt_secure_config.pasn_config.passphrase,
		aidl_config.secureConfig->pasnConfig.passphrase->data(),
		aidl_config.secureConfig->pasnConfig.passphrase->size());
		}
		if (aidl_config.secureConfig->pasnConfig.pmkid.has_value() &&
		aidl_config.secureConfig->pasnConfig.pmkid->size() == PMKID_LEN) {
		legacy_config->rtt_secure_config.pasn_config.pmkid_len =
		aidl_config.secureConfig->pasnConfig.pmkid->size();
		memcpy(legacy_config->rtt_secure_config.pasn_config.pmkid,
		aidl_config.secureConfig->pasnConfig.pmkid->data(),
		aidl_config.secureConfig->pasnConfig.pmkid->size());
		}
		}

		return true;
		}

		bool convertAidlVectorOfRttConfigToLegacy(
		const std::vector<RttConfig>& aidl_configs,
		std::vector<legacy_hal::wifi_rtt_config>* legacy_configs) {
		@@ -2849,6 +2981,23 @@ bool convertAidlVectorOfRttConfigToLegacyV3(
		return true;
		}

		bool convertAidlVectorOfRttConfigToLegacyV4(
		const std::vector<RttConfig>& aidl_configs,
		std::vector<legacy_hal::wifi_rtt_config_v4>* legacy_configs) {
		if (!legacy_configs) {
		return false;
		}
		*legacy_configs = {};
		for (const auto& aidl_config : aidl_configs) {
		legacy_hal::wifi_rtt_config_v4 legacy_config;
		if (!convertAidlRttConfigToLegacyV4(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) {
		@@ -2959,6 +3108,12 @@ bool convertLegacyRttCapabilitiesToAidl(
		aidl_capabilities->azBwSupport = (int)RttBw::BW_UNSPECIFIED;
		aidl_capabilities->ntbInitiatorSupported = false;
		aidl_capabilities->ntbResponderSupported = false;
		// Initialize 11az secure ranging parameters to default
		aidl_capabilities->akmsSupported = Akm::NONE;
		aidl_capabilities->cipherSuitesSupported = CipherSuite::NONE;
		aidl_capabilities->secureHeLtfSupported = false;
		aidl_capabilities->rangingFrameProtectionSupported = false;
		aidl_capabilities->maxSupportedSecureHeLtfProtocolVersion = false;
		return true;
		}

		@@ -2986,6 +3141,53 @@ bool convertLegacyRttCapabilitiesV3ToAidl(
		(int)convertLegacyRttBwBitmapToAidl(legacy_capabilities_v3.az_bw_support);
		aidl_capabilities->ntbInitiatorSupported = legacy_capabilities_v3.ntb_initiator_supported;
		aidl_capabilities->ntbResponderSupported = legacy_capabilities_v3.ntb_responder_supported;
		// Initialize 11az secure ranging parameters to default
		aidl_capabilities->akmsSupported = Akm::NONE;
		aidl_capabilities->cipherSuitesSupported = CipherSuite::NONE;
		aidl_capabilities->secureHeLtfSupported = false;
		aidl_capabilities->rangingFrameProtectionSupported = false;
		aidl_capabilities->maxSupportedSecureHeLtfProtocolVersion = false;

		return true;
		}

		bool convertLegacyRttCapabilitiesV4ToAidl(
		const legacy_hal::wifi_rtt_capabilities_v4& legacy_capabilities_v4,
		RttCapabilities* aidl_capabilities) {
		if (!aidl_capabilities) {
		return false;
		}
		*aidl_capabilities = {};
		aidl_capabilities->rttOneSidedSupported =
		legacy_capabilities_v4.rtt_capab_v3.rtt_capab.rtt_one_sided_supported;
		aidl_capabilities->rttFtmSupported =
		legacy_capabilities_v4.rtt_capab_v3.rtt_capab.rtt_ftm_supported;
		aidl_capabilities->lciSupported = legacy_capabilities_v4.rtt_capab_v3.rtt_capab.lci_support;
		aidl_capabilities->lcrSupported = legacy_capabilities_v4.rtt_capab_v3.rtt_capab.lcr_support;
		aidl_capabilities->responderSupported =
		legacy_capabilities_v4.rtt_capab_v3.rtt_capab.responder_supported;
		aidl_capabilities->preambleSupport = convertLegacyRttPreambleBitmapToAidl(
		legacy_capabilities_v4.rtt_capab_v3.rtt_capab.preamble_support);
		aidl_capabilities->bwSupport = convertLegacyRttBwBitmapToAidl(
		legacy_capabilities_v4.rtt_capab_v3.rtt_capab.bw_support);
		aidl_capabilities->mcVersion = legacy_capabilities_v4.rtt_capab_v3.rtt_capab.mc_version;
		aidl_capabilities->azPreambleSupport = (int)convertLegacyRttPreambleBitmapToAidl(
		legacy_capabilities_v4.rtt_capab_v3.az_preamble_support);
		aidl_capabilities->azBwSupport =
		(int)convertLegacyRttBwBitmapToAidl(legacy_capabilities_v4.rtt_capab_v3.az_bw_support);
		aidl_capabilities->ntbInitiatorSupported =
		legacy_capabilities_v4.rtt_capab_v3.ntb_initiator_supported;
		aidl_capabilities->ntbResponderSupported =
		legacy_capabilities_v4.rtt_capab_v3.ntb_responder_supported;
		aidl_capabilities->akmsSupported =
		convertLegacyAkmsToAidl(legacy_capabilities_v4.supported_akms);
		aidl_capabilities->cipherSuitesSupported =
		convertLegacyCipherSuitesToAidl(legacy_capabilities_v4.supported_cipher_suites);
		aidl_capabilities->secureHeLtfSupported = legacy_capabilities_v4.secure_he_ltf_supported;
		aidl_capabilities->rangingFrameProtectionSupported =
		legacy_capabilities_v4.ranging_fame_protection_supported;
		aidl_capabilities->maxSupportedSecureHeLtfProtocolVersion =
		legacy_capabilities_v4.max_supported_secure_he_ltf_protocol_ver;
		return true;
		}

		@@ -3066,6 +3268,13 @@ bool convertLegacyVectorOfRttResultToAidl(
		aidl_result.ntbMaxMeasurementTime = 0;
		aidl_result.numTxSpatialStreams = 0;
		aidl_result.numRxSpatialStreams = 0;
		aidl_result.isRangingFrameProtectionEnabled = false;
		aidl_result.isSecureLtfEnabled = false;
		aidl_result.baseAkm = Akm::NONE;
		aidl_result.cipherSuite = CipherSuite::NONE;
		aidl_result.secureHeLtfProtocolVersion = 0;
		aidl_result.pasnComebackAfterMillis = 0;
		aidl_result.pasnComebackCookie = std::nullopt;
		aidl_results->push_back(aidl_result);
		}
		return true;
		@@ -3092,6 +3301,13 @@ bool convertLegacyVectorOfRttResultV2ToAidl(
		aidl_result.ntbMaxMeasurementTime = 0;
		aidl_result.numTxSpatialStreams = 0;
		aidl_result.numRxSpatialStreams = 0;
		aidl_result.isRangingFrameProtectionEnabled = false;
		aidl_result.isSecureLtfEnabled = false;
		aidl_result.baseAkm = Akm::NONE;
		aidl_result.cipherSuite = CipherSuite::NONE;
		aidl_result.secureHeLtfProtocolVersion = 0;
		aidl_result.pasnComebackAfterMillis = 0;
		aidl_result.pasnComebackCookie = std::nullopt;
		aidl_results->push_back(aidl_result);
		}
		return true;
		@@ -3119,6 +3335,57 @@ bool convertLegacyVectorOfRttResultV3ToAidl(
		aidl_result.ntbMaxMeasurementTime = legacy_result->ntb_max_measurement_time;
		aidl_result.numTxSpatialStreams = legacy_result->num_tx_sts;
		aidl_result.numRxSpatialStreams = legacy_result->num_rx_sts;
		aidl_result.isRangingFrameProtectionEnabled = false;
		aidl_result.isSecureLtfEnabled = false;
		aidl_result.baseAkm = Akm::NONE;
		aidl_result.cipherSuite = CipherSuite::NONE;
		aidl_result.secureHeLtfProtocolVersion = 0;
		aidl_result.pasnComebackAfterMillis = 0;
		aidl_result.pasnComebackCookie = std::nullopt;
		aidl_results->push_back(aidl_result);
		}
		return true;
		}

		bool convertLegacyVectorOfRttResultV4ToAidl(
		const std::vector<const legacy_hal::wifi_rtt_result_v4*>& 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->rtt_result_v3.rtt_result.rtt_result,
		&aidl_result)) {
		return false;
		}
		aidl_result.channelFreqMHz =
		legacy_result->rtt_result_v3.rtt_result.frequency != UNSPECIFIED
		? legacy_result->rtt_result_v3.rtt_result.frequency
		: 0;
		aidl_result.packetBw =
		convertLegacyRttBwToAidl(legacy_result->rtt_result_v3.rtt_result.packet_bw);
		aidl_result.i2rTxLtfRepetitionCount =
		legacy_result->rtt_result_v3.i2r_tx_ltf_repetition_count;
		aidl_result.r2iTxLtfRepetitionCount =
		legacy_result->rtt_result_v3.r2i_tx_ltf_repetition_count;
		aidl_result.ntbMinMeasurementTime = legacy_result->rtt_result_v3.ntb_min_measurement_time;
		aidl_result.ntbMaxMeasurementTime = legacy_result->rtt_result_v3.ntb_max_measurement_time;
		aidl_result.numTxSpatialStreams = legacy_result->rtt_result_v3.num_tx_sts;
		aidl_result.numRxSpatialStreams = legacy_result->rtt_result_v3.num_rx_sts;
		aidl_result.isRangingFrameProtectionEnabled = legacy_result->is_ranging_protection_enabled;
		aidl_result.isSecureLtfEnabled = legacy_result->is_secure_he_ltf_enabled;
		aidl_result.baseAkm = convertLegacyAkmsToAidl(legacy_result->base_akm);
		aidl_result.cipherSuite = convertLegacyCipherSuitesToAidl(legacy_result->cipher_suite);
		aidl_result.secureHeLtfProtocolVersion = legacy_result->secure_he_ltf_protocol_version;
		aidl_result.pasnComebackAfterMillis = legacy_result->pasn_comeback_after_millis;
		if (legacy_result->pasn_comeback_cookie_len > 0 &&
		legacy_result->pasn_comeback_cookie_len <= RTT_MAX_COOKIE_LEN) {
		aidl_result.pasnComebackCookie = std::vector<uint8_t>(
		legacy_result->pasn_comeback_cookie,
		legacy_result->pasn_comeback_cookie + legacy_result->pasn_comeback_cookie_len);
		}
		aidl_results->push_back(aidl_result);
		}
		return true;

wifi/aidl/default/aidl_struct_util.h

+12 −0

Original line number	Diff line number	Diff line
		@@ -17,6 +17,8 @@
		#ifndef AIDL_STRUCT_UTIL_H_
		#define AIDL_STRUCT_UTIL_H_

		#include <aidl/android/hardware/wifi/Akm.h>
		#include <aidl/android/hardware/wifi/CipherSuite.h>
		#include <aidl/android/hardware/wifi/IWifiChip.h>
		#include <aidl/android/hardware/wifi/IWifiChipEventCallback.h>
		#include <aidl/android/hardware/wifi/NanBandIndex.h>
		@@ -153,6 +155,10 @@ bool convertAidlVectorOfRttConfigToLegacyV3(
		const std::vector<RttConfig>& aidl_configs,
		std::vector<legacy_hal::wifi_rtt_config_v3>* legacy_configs);

		bool convertAidlVectorOfRttConfigToLegacyV4(
		const std::vector<RttConfig>& aidl_configs,
		std::vector<legacy_hal::wifi_rtt_config_v4>* legacy_configs);

		bool convertAidlRttLciInformationToLegacy(const RttLciInformation& aidl_info,
		legacy_hal::wifi_lci_information* legacy_info);
		bool convertAidlRttLcrInformationToLegacy(const RttLcrInformation& aidl_info,
		@@ -169,6 +175,9 @@ bool convertLegacyRttCapabilitiesToAidl(
		bool convertLegacyRttCapabilitiesV3ToAidl(
		const legacy_hal::wifi_rtt_capabilities_v3& legacy_capabilities_v3,
		RttCapabilities* aidl_capabilities);
		bool convertLegacyRttCapabilitiesV4ToAidl(
		const legacy_hal::wifi_rtt_capabilities_v4& legacy_capabilities_v4,
		RttCapabilities* aidl_capabilities);

		bool convertLegacyVectorOfRttResultToAidl(
		const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
		@@ -179,6 +188,9 @@ bool convertLegacyVectorOfRttResultV2ToAidl(
		bool convertLegacyVectorOfRttResultV3ToAidl(
		const std::vector<const legacy_hal::wifi_rtt_result_v3*>& legacy_results,
		std::vector<RttResult>* aidl_results);
		bool convertLegacyVectorOfRttResultV4ToAidl(
		const std::vector<const legacy_hal::wifi_rtt_result_v4*>& 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);

wifi/aidl/default/wifi_legacy_hal.cpp

+52 −0

Original line number	Diff line number	Diff line
		@@ -185,11 +185,14 @@ std::function<void(wifi_request_id, unsigned num_results, wifi_rtt_result_v2* rt
		on_rtt_results_internal_callback_v2;
		std::function<void(wifi_request_id, unsigned num_results, wifi_rtt_result_v3* rtt_results_v3[])>
		on_rtt_results_internal_callback_v3;
		std::function<void(wifi_request_id, unsigned num_results, wifi_rtt_result_v4* rtt_results_v4[])>
		on_rtt_results_internal_callback_v4;

		void invalidateRttResultsCallbacks() {
		on_rtt_results_internal_callback = nullptr;
		on_rtt_results_internal_callback_v2 = nullptr;
		on_rtt_results_internal_callback_v3 = nullptr;
		on_rtt_results_internal_callback_v4 = nullptr;
		};

		void onAsyncRttResults(wifi_request_id id, unsigned num_results, wifi_rtt_result* rtt_results[]) {
		@@ -218,6 +221,15 @@ void onAsyncRttResultsV3(wifi_request_id id, unsigned num_results,
		}
		}

		void onAsyncRttResultsV4(wifi_request_id id, unsigned num_results,
		wifi_rtt_result_v4* rtt_results_v4[]) {
		const auto lock = aidl_sync_util::acquireGlobalLock();
		if (on_rtt_results_internal_callback_v4) {
		on_rtt_results_internal_callback_v4(id, num_results, rtt_results_v4);
		invalidateRttResultsCallbacks();
		}
		}

		// Callbacks for the various NAN operations.
		// NOTE: These have very little conversions to perform before invoking the user
		// callbacks.
		@@ -1344,6 +1356,38 @@ wifi_error WifiLegacyHal::registerSubsystemRestartCallbackHandler(
		return status;
		}

		wifi_error WifiLegacyHal::startRttRangeRequestV4(
		const std::string& iface_name, wifi_request_id id,
		const std::vector<wifi_rtt_config_v4>& rtt_configs,
		const on_rtt_results_callback_v4& on_results_user_callback_v4) {
		if (on_rtt_results_internal_callback_v4) {
		return WIFI_ERROR_NOT_AVAILABLE;
		}

		on_rtt_results_internal_callback_v4 = [on_results_user_callback_v4](
		wifi_request_id id, unsigned num_results,
		wifi_rtt_result_v4* rtt_results_v4[]) {
		if (num_results > 0 && !rtt_results_v4) {
		LOG(ERROR) << "Unexpected nullptr in RTT v4 results";
		return;
		}
		std::vector<const wifi_rtt_result_v4*> rtt_results_vec_v4;
		std::copy_if(rtt_results_v4, rtt_results_v4 + num_results,
		back_inserter(rtt_results_vec_v4),
		[](wifi_rtt_result_v4* rtt_result_v4) { return rtt_result_v4 != nullptr; });
		on_results_user_callback_v4(id, rtt_results_vec_v4);
		};

		std::vector<wifi_rtt_config_v4> rtt_configs_internal(rtt_configs);
		wifi_error status = global_func_table_.wifi_rtt_range_request_v4(
		id, getIfaceHandle(iface_name), rtt_configs.size(), rtt_configs_internal.data(),
		{onAsyncRttResultsV4});
		if (status != WIFI_SUCCESS) {
		invalidateRttResultsCallbacks();
		}
		return status;
		}

		wifi_error WifiLegacyHal::startRttRangeRequestV3(
		const std::string& iface_name, wifi_request_id id,
		const std::vector<wifi_rtt_config_v3>& rtt_configs,
		@@ -1460,6 +1504,14 @@ std::pair<wifi_error, wifi_rtt_capabilities_v3> WifiLegacyHal::getRttCapabilitie
		return {status, rtt_caps_v3};
		}

		std::pair<wifi_error, wifi_rtt_capabilities_v4> WifiLegacyHal::getRttCapabilitiesV4(
		const std::string& iface_name) {
		wifi_rtt_capabilities_v4 rtt_caps_v4;
		wifi_error status = global_func_table_.wifi_get_rtt_capabilities_v4(getIfaceHandle(iface_name),
		&rtt_caps_v4);
		return {status, rtt_caps_v4};
		}

		std::pair<wifi_error, wifi_rtt_responder> WifiLegacyHal::getRttResponderInfo(
		const std::string& iface_name) {
		wifi_rtt_responder rtt_responder;

wifi/aidl/default/wifi_legacy_hal.h

+26 −0

Original line number	Diff line number	Diff line
		@@ -350,6 +350,7 @@ using ::wifi_request_id;
		using ::wifi_ring_buffer_status;
		using ::wifi_roaming_capabilities;
		using ::wifi_roaming_config;
		using ::wifi_rtt_akm;
		using ::wifi_rtt_bw;
		using ::WIFI_RTT_BW_10;
		using ::WIFI_RTT_BW_160;
		@@ -361,8 +362,11 @@ using ::WIFI_RTT_BW_80;
		using ::WIFI_RTT_BW_UNSPECIFIED;
		using ::wifi_rtt_capabilities;
		using ::wifi_rtt_capabilities_v3;
		using ::wifi_rtt_capabilities_v4;
		using ::wifi_rtt_cipher_suite;
		using ::wifi_rtt_config;
		using ::wifi_rtt_config_v3;
		using ::wifi_rtt_config_v4;
		using ::wifi_rtt_preamble;
		using ::WIFI_RTT_PREAMBLE_EHT;
		using ::WIFI_RTT_PREAMBLE_HE;
		@@ -374,6 +378,7 @@ using ::wifi_rtt_responder;
		using ::wifi_rtt_result;
		using ::wifi_rtt_result_v2;
		using ::wifi_rtt_result_v3;
		using ::wifi_rtt_result_v4;
		using ::wifi_rtt_status;
		using ::wifi_rtt_type;
		using ::wifi_rx_packet_fate;
		@@ -399,6 +404,20 @@ using ::WLAN_MAC_2_4_BAND;
		using ::WLAN_MAC_5_0_BAND;
		using ::WLAN_MAC_60_0_BAND;
		using ::WLAN_MAC_6_0_BAND;
		using ::WPA_CIPHER_CCMP_128;
		using ::WPA_CIPHER_CCMP_256;
		using ::WPA_CIPHER_GCMP_128;
		using ::WPA_CIPHER_GCMP_256;
		using ::WPA_CIPHER_NONE;
		using ::WPA_KEY_MGMT_EAP_FILS_SHA256;
		using ::WPA_KEY_MGMT_EAP_FILS_SHA384;
		using ::WPA_KEY_MGMT_EAP_FT_SHA256;
		using ::WPA_KEY_MGMT_EAP_FT_SHA384;
		using ::WPA_KEY_MGMT_FT_PSK_SHA256;
		using ::WPA_KEY_MGMT_FT_PSK_SHA384;
		using ::WPA_KEY_MGMT_NONE;
		using ::WPA_KEY_MGMT_PASN;
		using ::WPA_KEY_MGMT_SAE;

		// APF capabilities supported by the iface.
		struct PacketFilterCapabilities {
		@@ -517,6 +536,8 @@ using on_rtt_results_callback_v2 =
		std::function<void(wifi_request_id, const std::vector<const wifi_rtt_result_v2*>&)>;
		using on_rtt_results_callback_v3 =
		std::function<void(wifi_request_id, const std::vector<const wifi_rtt_result_v3*>&)>;
		using on_rtt_results_callback_v4 =
		std::function<void(wifi_request_id, const std::vector<const wifi_rtt_result_v4*>&)>;

		// Callback for ring buffer data.
		using on_ring_buffer_data_callback = std::function<void(
		@@ -705,12 +726,17 @@ class WifiLegacyHal {
		wifi_error startRttRangeRequestV3(const std::string& iface_name, wifi_request_id id,
		const std::vector<wifi_rtt_config_v3>& rtt_configs,
		const on_rtt_results_callback_v3& on_results_callback);
		wifi_error startRttRangeRequestV4(const std::string& iface_name, wifi_request_id id,
		const std::vector<wifi_rtt_config_v4>& rtt_configs,
		const on_rtt_results_callback_v4& 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);
		std::pair<wifi_error, wifi_rtt_capabilities> getRttCapabilities(const std::string& iface_name);
		std::pair<wifi_error, wifi_rtt_capabilities_v3> getRttCapabilitiesV3(
		const std::string& iface_name);
		std::pair<wifi_error, wifi_rtt_capabilities_v4> getRttCapabilitiesV4(
		const std::string& iface_name);
		std::pair<wifi_error, wifi_rtt_responder> getRttResponderInfo(const std::string& iface_name);
		wifi_error enableRttResponder(const std::string& iface_name, wifi_request_id id,
		const wifi_channel_info& channel_hint, uint32_t max_duration_secs,

wifi/aidl/default/wifi_legacy_hal_stubs.cpp

+2 −0

Original line number	Diff line number	Diff line
		@@ -180,7 +180,9 @@ bool initHalFuncTableWithStubs(wifi_hal_fn* hal_fn) {
		populateStubFor(&hal_fn->wifi_set_mlo_mode);
		populateStubFor(&hal_fn->wifi_get_supported_iface_concurrency_matrix);
		populateStubFor(&hal_fn->wifi_get_rtt_capabilities_v3);
		populateStubFor(&hal_fn->wifi_get_rtt_capabilities_v4);
		populateStubFor(&hal_fn->wifi_rtt_range_request_v3);
		populateStubFor(&hal_fn->wifi_rtt_range_request_v4);
		populateStubFor(&hal_fn->wifi_twt_get_capabilities);
		populateStubFor(&hal_fn->wifi_twt_register_events);
		populateStubFor(&hal_fn->wifi_twt_session_setup);