Merge changes I5a617557,Idca8de42 (d462a317) · Commits · e / os / android_hardware_interfaces

wifi/1.3/default/tests/mock_wifi_legacy_hal.h

+6 −0

Original line number	Diff line number	Diff line
		@@ -43,6 +43,12 @@ class MockWifiLegacyHal : public WifiLegacyHal {
		const std::string& iface_name));
		MOCK_METHOD1(getDriverVersion, std::pair<wifi_error, std::string>(
		const std::string& iface_name));

		MOCK_METHOD2(selectTxPowerScenario,
		wifi_error(const std::string& iface_name,
		wifi_power_scenario scenario));
		MOCK_METHOD1(resetTxPowerScenario,
		wifi_error(const std::string& iface_name));
		MOCK_METHOD2(nanRegisterCallbackHandlers,
		wifi_error(const std::string&, const NanCallbackHandlers&));
		MOCK_METHOD2(nanDisableRequest,

wifi/1.3/default/tests/wifi_chip_unit_tests.cpp

+96 −26

Original line number	Diff line number	Diff line
		@@ -122,7 +122,7 @@ class WifiChipTest : public Test {
		void setup_MultiIfaceCombination() {
		// clang-format off
		const hidl_vec<V1_0::IWifiChip::ChipIfaceCombination> combinations = {
		{{{{IfaceType::STA}, 3}}}
		{{{{IfaceType::STA}, 3}, {{IfaceType::AP}, 1}}}
		};
		const std::vector<V1_0::IWifiChip::ChipMode> modes = {
		{feature_flags::chip_mode_ids::kV3, combinations}
		@@ -261,6 +261,17 @@ class WifiChipTest : public Test {
		return success;
		}

		sp<WifiChip> chip_;
		ChipId chip_id_ = kFakeChipId;
		std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
		new NiceMock<legacy_hal::MockWifiLegacyHal>};
		std::shared_ptr<NiceMock<mode_controller::MockWifiModeController>>
		mode_controller_{new NiceMock<mode_controller::MockWifiModeController>};
		std::shared_ptr<NiceMock<iface_util::MockWifiIfaceUtil>> iface_util_{
		new NiceMock<iface_util::MockWifiIfaceUtil>};
		std::shared_ptr<NiceMock<feature_flags::MockWifiFeatureFlags>>
		feature_flags_{new NiceMock<feature_flags::MockWifiFeatureFlags>};

		public:
		void SetUp() override {
		chip_ = new WifiChip(chip_id_, legacy_hal_, mode_controller_,
		@@ -272,17 +283,12 @@ class WifiChipTest : public Test {
		.WillRepeatedly(testing::Return(legacy_hal::WIFI_SUCCESS));
		}

		private:
		sp<WifiChip> chip_;
		ChipId chip_id_ = kFakeChipId;
		std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
		new NiceMock<legacy_hal::MockWifiLegacyHal>};
		std::shared_ptr<NiceMock<mode_controller::MockWifiModeController>>
		mode_controller_{new NiceMock<mode_controller::MockWifiModeController>};
		std::shared_ptr<NiceMock<iface_util::MockWifiIfaceUtil>> iface_util_{
		new NiceMock<iface_util::MockWifiIfaceUtil>};
		std::shared_ptr<NiceMock<feature_flags::MockWifiFeatureFlags>>
		feature_flags_{new NiceMock<feature_flags::MockWifiFeatureFlags>};
		void TearDown() override {
		// Restore default system iface names (This should ideally be using a
		// mock).
		property_set("wifi.interface", "wlan0");
		property_set("wifi.concurrent.interface", "wlan1");
		}
		};

		////////// V1 Iface Combinations ////////////
		@@ -300,7 +306,7 @@ class WifiChipV1IfaceCombinationTest : public WifiChipTest {

		TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateSta_ShouldSucceed) {
		findModeAndConfigureForIfaceType(IfaceType::STA);
		ASSERT_FALSE(createIface(IfaceType::STA).empty());
		ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
		}

		TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateP2p_ShouldSucceed) {
		@@ -326,7 +332,7 @@ TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateStaP2p_ShouldSucceed) {

		TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateAp_ShouldSucceed) {
		findModeAndConfigureForIfaceType(IfaceType::AP);
		ASSERT_FALSE(createIface(IfaceType::AP).empty());
		ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
		}

		TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateSta_ShouldFail) {
		@@ -359,7 +365,7 @@ class WifiChipV1_AwareIfaceCombinationTest : public WifiChipTest {

		TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateSta_ShouldSucceed) {
		findModeAndConfigureForIfaceType(IfaceType::STA);
		ASSERT_FALSE(createIface(IfaceType::STA).empty());
		ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
		}

		TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateP2p_ShouldSucceed) {
		@@ -427,7 +433,7 @@ TEST_F(WifiChipV1_AwareIfaceCombinationTest,

		TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateAp_ShouldSucceed) {
		findModeAndConfigureForIfaceType(IfaceType::AP);
		ASSERT_FALSE(createIface(IfaceType::AP).empty());
		ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
		}

		TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateSta_ShouldFail) {
		@@ -445,18 +451,18 @@ TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateNan_ShouldFail) {
		ASSERT_TRUE(createIface(IfaceType::NAN).empty());
		}

		TEST_F(WifiChipV1IfaceCombinationTest, RttControllerFlowStaModeNoSta) {
		TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowStaModeNoSta) {
		findModeAndConfigureForIfaceType(IfaceType::STA);
		ASSERT_TRUE(createRttController());
		}

		TEST_F(WifiChipV1IfaceCombinationTest, RttControllerFlowStaModeWithSta) {
		TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowStaModeWithSta) {
		findModeAndConfigureForIfaceType(IfaceType::STA);
		ASSERT_FALSE(createIface(IfaceType::STA).empty());
		ASSERT_TRUE(createRttController());
		}

		TEST_F(WifiChipV1IfaceCombinationTest, RttControllerFlowApToSta) {
		TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowApToSta) {
		findModeAndConfigureForIfaceType(IfaceType::AP);
		const auto ap_iface_name = createIface(IfaceType::AP);
		ASSERT_FALSE(ap_iface_name.empty());
		@@ -468,6 +474,30 @@ TEST_F(WifiChipV1IfaceCombinationTest, RttControllerFlowApToSta) {
		ASSERT_TRUE(createRttController());
		}

		TEST_F(WifiChipV1_AwareIfaceCombinationTest, SelectTxScenarioWithOnlySta) {
		findModeAndConfigureForIfaceType(IfaceType::STA);
		ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
		EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
		.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
		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) {
		findModeAndConfigureForIfaceType(IfaceType::AP);
		ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
		EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
		.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
		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 ////////////
		// Mode 1 - STA + STA/AP
		// - STA + P2P/NAN
		@@ -483,7 +513,7 @@ class WifiChipV2_AwareIfaceCombinationTest : public WifiChipTest {

		TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateSta_ShouldSucceed) {
		findModeAndConfigureForIfaceType(IfaceType::STA);
		ASSERT_FALSE(createIface(IfaceType::STA).empty());
		ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
		}

		TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateP2p_ShouldSucceed) {
		@@ -498,19 +528,25 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNan_ShouldSucceed) {

		TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateAp_ShouldSucceed) {
		findModeAndConfigureForIfaceType(IfaceType::STA);
		ASSERT_FALSE(createIface(IfaceType::AP).empty());
		ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
		}

		TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaSta_ShouldFail) {
		findModeAndConfigureForIfaceType(IfaceType::AP);
		ASSERT_FALSE(createIface(IfaceType::STA).empty());
		ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
		ASSERT_TRUE(createIface(IfaceType::STA).empty());
		}

		TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaAp_ShouldSucceed) {
		findModeAndConfigureForIfaceType(IfaceType::AP);
		ASSERT_FALSE(createIface(IfaceType::AP).empty());
		ASSERT_FALSE(createIface(IfaceType::STA).empty());
		ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
		ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
		}

		TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApSta_ShouldSucceed) {
		findModeAndConfigureForIfaceType(IfaceType::AP);
		ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
		ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
		}

		TEST_F(WifiChipV2_AwareIfaceCombinationTest,
		@@ -640,6 +676,30 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, RttControllerFlow) {
		ASSERT_TRUE(createRttController());
		}

		TEST_F(WifiChipV2_AwareIfaceCombinationTest, SelectTxScenarioWithOnlySta) {
		findModeAndConfigureForIfaceType(IfaceType::STA);
		ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
		EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
		.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
		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) {
		findModeAndConfigureForIfaceType(IfaceType::AP);
		ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
		EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan1", testing::_))
		.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
		chip_->selectTxPowerScenario_1_2(
		V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
		[](const WifiStatus& status) {
		ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
		});
		}

		////////// V1 Iface Combinations when AP creation is disabled //////////
		class WifiChipV1_AwareDisabledApIfaceCombinationTest : public WifiChipTest {
		public:
		@@ -707,8 +767,8 @@ TEST_F(WifiChip_MultiIfaceTest, CreateStaWithCustomNames) {
		property_set("wifi.interface", "bad0");
		property_set("wifi.concurrent.interface", "bad1");
		findModeAndConfigureForIfaceType(IfaceType::STA);
		ASSERT_EQ(createIface(IfaceType::STA), "test0");
		ASSERT_EQ(createIface(IfaceType::STA), "test1");
		ASSERT_EQ(createIface(IfaceType::STA), "bad0");
		ASSERT_EQ(createIface(IfaceType::STA), "bad1");
		ASSERT_EQ(createIface(IfaceType::STA), "test2");
		}

		@@ -724,6 +784,16 @@ TEST_F(WifiChip_MultiIfaceTest, CreateStaWithCustomAltNames) {
		ASSERT_EQ(createIface(IfaceType::STA), "wlan2");
		}

		TEST_F(WifiChip_MultiIfaceTest, CreateApStartsWithIdx1) {
		findModeAndConfigureForIfaceType(IfaceType::STA);
		// First AP will be slotted to wlan1.
		ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
		// First STA will be slotted to wlan0.
		ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
		// All further STA will be slotted to the remaining free indices.
		ASSERT_EQ(createIface(IfaceType::STA), "wlan2");
		ASSERT_EQ(createIface(IfaceType::STA), "wlan3");
		}
		} // namespace implementation
		} // namespace V1_3
		} // namespace wifi

wifi/1.3/default/wifi_chip.cpp

+134 −38

Original line number	Diff line number	Diff line
		@@ -641,7 +641,7 @@ std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal_1_3() {
		legacy_hal::wifi_error legacy_status;
		uint32_t legacy_feature_set;
		uint32_t legacy_logger_feature_set;
		const auto ifname = getWlanIfaceName(0);
		const auto ifname = getFirstActiveWlanIfaceName();
		std::tie(legacy_status, legacy_feature_set) =
		legacy_hal_.lock()->getSupportedFeatureSet(ifname);
		if (legacy_status != legacy_hal::WIFI_SUCCESS) {
		@@ -709,7 +709,7 @@ WifiChip::requestChipDebugInfoInternal() {
		IWifiChip::ChipDebugInfo result;
		legacy_hal::wifi_error legacy_status;
		std::string driver_desc;
		const auto ifname = getWlanIfaceName(0);
		const auto ifname = getFirstActiveWlanIfaceName();
		std::tie(legacy_status, driver_desc) =
		legacy_hal_.lock()->getDriverVersion(ifname);
		if (legacy_status != legacy_hal::WIFI_SUCCESS) {
		@@ -741,7 +741,8 @@ WifiChip::requestDriverDebugDumpInternal() {
		legacy_hal::wifi_error legacy_status;
		std::vector<uint8_t> driver_dump;
		std::tie(legacy_status, driver_dump) =
		legacy_hal_.lock()->requestDriverMemoryDump(getWlanIfaceName(0));
		legacy_hal_.lock()->requestDriverMemoryDump(
		getFirstActiveWlanIfaceName());
		if (legacy_status != legacy_hal::WIFI_SUCCESS) {
		LOG(ERROR) << "Failed to get driver debug dump: "
		<< legacyErrorToString(legacy_status);
		@@ -756,7 +757,8 @@ WifiChip::requestFirmwareDebugDumpInternal() {
		legacy_hal::wifi_error legacy_status;
		std::vector<uint8_t> firmware_dump;
		std::tie(legacy_status, firmware_dump) =
		legacy_hal_.lock()->requestFirmwareMemoryDump(getWlanIfaceName(0));
		legacy_hal_.lock()->requestFirmwareMemoryDump(
		getFirstActiveWlanIfaceName());
		if (legacy_status != legacy_hal::WIFI_SUCCESS) {
		LOG(ERROR) << "Failed to get firmware debug dump: "
		<< legacyErrorToString(legacy_status);
		@@ -766,10 +768,10 @@ WifiChip::requestFirmwareDebugDumpInternal() {
		}

		std::pair<WifiStatus, sp<IWifiApIface>> WifiChip::createApIfaceInternal() {
		if (!canCurrentModeSupportIfaceOfType(IfaceType::AP)) {
		if (!canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType::AP)) {
		return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
		}
		std::string ifname = allocateApOrStaIfaceName();
		std::string ifname = allocateApIfaceName();
		sp<WifiApIface> iface =
		new WifiApIface(ifname, legacy_hal_, iface_util_, feature_flags_);
		ap_ifaces_.push_back(iface);
		@@ -813,11 +815,11 @@ WifiStatus WifiChip::removeApIfaceInternal(const std::string& ifname) {
		}

		std::pair<WifiStatus, sp<IWifiNanIface>> WifiChip::createNanIfaceInternal() {
		if (!canCurrentModeSupportIfaceOfType(IfaceType::NAN)) {
		if (!canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType::NAN)) {
		return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
		}
		// These are still assumed to be based on wlan0.
		std::string ifname = getWlanIfaceName(0);
		std::string ifname = getFirstActiveWlanIfaceName();
		sp<WifiNanIface> iface = new WifiNanIface(ifname, legacy_hal_);
		nan_ifaces_.push_back(iface);
		for (const auto& callback : event_cb_handler_.getCallbacks()) {
		@@ -860,7 +862,7 @@ WifiStatus WifiChip::removeNanIfaceInternal(const std::string& ifname) {
		}

		std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::createP2pIfaceInternal() {
		if (!canCurrentModeSupportIfaceOfType(IfaceType::P2P)) {
		if (!canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType::P2P)) {
		return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
		}
		std::string ifname = getP2pIfaceName();
		@@ -906,10 +908,10 @@ WifiStatus WifiChip::removeP2pIfaceInternal(const std::string& ifname) {
		}

		std::pair<WifiStatus, sp<IWifiStaIface>> WifiChip::createStaIfaceInternal() {
		if (!canCurrentModeSupportIfaceOfType(IfaceType::STA)) {
		if (!canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType::STA)) {
		return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
		}
		std::string ifname = allocateApOrStaIfaceName();
		std::string ifname = allocateStaIfaceName();
		sp<WifiStaIface> iface = new WifiStaIface(ifname, legacy_hal_, iface_util_);
		sta_ifaces_.push_back(iface);
		for (const auto& callback : event_cb_handler_.getCallbacks()) {
		@@ -959,8 +961,8 @@ WifiChip::createRttControllerInternal(const sp<IWifiIface>& bound_iface) {
		"(and RTT by extension)";
		return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
		}
		sp<WifiRttController> rtt =
		new WifiRttController(getWlanIfaceName(0), bound_iface, legacy_hal_);
		sp<WifiRttController> rtt = new WifiRttController(
		getFirstActiveWlanIfaceName(), bound_iface, legacy_hal_);
		rtt_controllers_.emplace_back(rtt);
		return {createWifiStatus(WifiStatusCode::SUCCESS), rtt};
		}
		@@ -971,7 +973,7 @@ WifiChip::getDebugRingBuffersStatusInternal() {
		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(getWlanIfaceName(0));
		legacy_hal_.lock()->getRingBuffersStatus(getFirstActiveWlanIfaceName());
		if (legacy_status != legacy_hal::WIFI_SUCCESS) {
		return {createWifiStatusFromLegacyError(legacy_status), {}};
		}
		@@ -993,7 +995,7 @@ WifiStatus WifiChip::startLoggingToDebugRingBufferInternal(
		}
		legacy_hal::wifi_error legacy_status =
		legacy_hal_.lock()->startRingBufferLogging(
		getWlanIfaceName(0), ring_name,
		getFirstActiveWlanIfaceName(), ring_name,
		static_cast<
		std::underlying_type<WifiDebugRingBufferVerboseLevel>::type>(
		verbose_level),
		@@ -1010,7 +1012,8 @@ WifiStatus WifiChip::forceDumpToDebugRingBufferInternal(
		return status;
		}
		legacy_hal::wifi_error legacy_status =
		legacy_hal_.lock()->getRingBufferData(getWlanIfaceName(0), ring_name);
		legacy_hal_.lock()->getRingBufferData(getFirstActiveWlanIfaceName(),
		ring_name);

		return createWifiStatusFromLegacyError(legacy_status);
		}
		@@ -1026,7 +1029,7 @@ WifiStatus WifiChip::flushRingBufferToFileInternal() {
		WifiStatus WifiChip::stopLoggingToDebugRingBufferInternal() {
		legacy_hal::wifi_error legacy_status =
		legacy_hal_.lock()->deregisterRingBufferCallbackHandler(
		getWlanIfaceName(0));
		getFirstActiveWlanIfaceName());
		return createWifiStatusFromLegacyError(legacy_status);
		}

		@@ -1035,7 +1038,7 @@ WifiChip::getDebugHostWakeReasonStatsInternal() {
		legacy_hal::wifi_error legacy_status;
		legacy_hal::WakeReasonStats legacy_stats;
		std::tie(legacy_status, legacy_stats) =
		legacy_hal_.lock()->getWakeReasonStats(getWlanIfaceName(0));
		legacy_hal_.lock()->getWakeReasonStats(getFirstActiveWlanIfaceName());
		if (legacy_status != legacy_hal::WIFI_SUCCESS) {
		return {createWifiStatusFromLegacyError(legacy_status), {}};
		}
		@@ -1067,10 +1070,10 @@ WifiStatus WifiChip::enableDebugErrorAlertsInternal(bool enable) {
		}
		};
		legacy_status = legacy_hal_.lock()->registerErrorAlertCallbackHandler(
		getWlanIfaceName(0), on_alert_callback);
		getFirstActiveWlanIfaceName(), on_alert_callback);
		} else {
		legacy_status = legacy_hal_.lock()->deregisterErrorAlertCallbackHandler(
		getWlanIfaceName(0));
		getFirstActiveWlanIfaceName());
		}
		return createWifiStatusFromLegacyError(legacy_status);
		}
		@@ -1078,20 +1081,20 @@ WifiStatus WifiChip::enableDebugErrorAlertsInternal(bool enable) {
		WifiStatus WifiChip::selectTxPowerScenarioInternal(
		V1_1::IWifiChip::TxPowerScenario scenario) {
		auto legacy_status = legacy_hal_.lock()->selectTxPowerScenario(
		getWlanIfaceName(0),
		getFirstActiveWlanIfaceName(),
		hidl_struct_util::convertHidlTxPowerScenarioToLegacy(scenario));
		return createWifiStatusFromLegacyError(legacy_status);
		}

		WifiStatus WifiChip::resetTxPowerScenarioInternal() {
		auto legacy_status =
		legacy_hal_.lock()->resetTxPowerScenario(getWlanIfaceName(0));
		legacy_hal_.lock()->resetTxPowerScenario(getFirstActiveWlanIfaceName());
		return createWifiStatusFromLegacyError(legacy_status);
		}

		WifiStatus WifiChip::setLatencyModeInternal(LatencyMode mode) {
		auto legacy_status = legacy_hal_.lock()->setLatencyMode(
		getWlanIfaceName(0),
		getFirstActiveWlanIfaceName(),
		hidl_struct_util::convertHidlLatencyModeToLegacy(mode));
		return createWifiStatusFromLegacyError(legacy_status);
		}
		@@ -1107,7 +1110,7 @@ WifiStatus WifiChip::registerEventCallbackInternal_1_2(
		WifiStatus WifiChip::selectTxPowerScenarioInternal_1_2(
		TxPowerScenario scenario) {
		auto legacy_status = legacy_hal_.lock()->selectTxPowerScenario(
		getWlanIfaceName(0),
		getFirstActiveWlanIfaceName(),
		hidl_struct_util::convertHidlTxPowerScenarioToLegacy_1_2(scenario));
		return createWifiStatusFromLegacyError(legacy_status);
		}
		@@ -1197,7 +1200,7 @@ WifiStatus WifiChip::registerDebugRingBufferCallback() {
		};
		legacy_hal::wifi_error legacy_status =
		legacy_hal_.lock()->registerRingBufferCallbackHandler(
		getWlanIfaceName(0), on_ring_buffer_data_callback);
		getFirstActiveWlanIfaceName(), on_ring_buffer_data_callback);

		if (legacy_status == legacy_hal::WIFI_SUCCESS) {
		debug_ring_buffer_cb_registered_ = true;
		@@ -1231,7 +1234,7 @@ WifiStatus WifiChip::registerRadioModeChangeCallback() {
		};
		legacy_hal::wifi_error legacy_status =
		legacy_hal_.lock()->registerRadioModeChangeCallbackHandler(
		getWlanIfaceName(0), on_radio_mode_change_callback);
		getFirstActiveWlanIfaceName(), on_radio_mode_change_callback);
		return createWifiStatusFromLegacyError(legacy_status);
		}

		@@ -1298,8 +1301,9 @@ std::vector<std::map<IfaceType, size_t>> WifiChip::expandIfaceCombinations(
		return expanded_combos;
		}

		bool WifiChip::canExpandedIfaceCombinationSupportIfaceOfType(
		const std::map<IfaceType, size_t>& combo, IfaceType requested_type) {
		bool WifiChip::canExpandedIfaceComboSupportIfaceOfTypeWithCurrentIfaces(
		const std::map<IfaceType, size_t>& expanded_combo,
		IfaceType requested_type) {
		const auto current_combo = getCurrentIfaceCombination();

		// Check if we have space for 1 more iface of \|type\| in this combo
		@@ -1309,7 +1313,7 @@ bool WifiChip::canExpandedIfaceCombinationSupportIfaceOfType(
		if (type == requested_type) {
		num_ifaces_needed++;
		}
		size_t num_ifaces_allowed = combo.at(type);
		size_t num_ifaces_allowed = expanded_combo.at(type);
		if (num_ifaces_needed > num_ifaces_allowed) {
		return false;
		}
		@@ -1320,8 +1324,10 @@ bool WifiChip::canExpandedIfaceCombinationSupportIfaceOfType(
		// This method does the following:
		// a) Enumerate all possible iface combos by expanding the current
		// ChipIfaceCombination.
		// b) Check if the requested iface type can be added to the current mode.
		bool WifiChip::canCurrentModeSupportIfaceOfType(IfaceType type) {
		// b) Check if the requested iface type can be added to the current mode
		// with the iface combination that is already active.
		bool WifiChip::canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(
		IfaceType requested_type) {
		if (!isValidModeId(current_mode_id_)) {
		LOG(ERROR) << "Chip not configured in a mode yet";
		return false;
		@@ -1330,8 +1336,8 @@ bool WifiChip::canCurrentModeSupportIfaceOfType(IfaceType type) {
		for (const auto& combination : combinations) {
		const auto expanded_combos = expandIfaceCombinations(combination);
		for (const auto& expanded_combo : expanded_combos) {
		if (canExpandedIfaceCombinationSupportIfaceOfType(expanded_combo,
		type)) {
		if (canExpandedIfaceComboSupportIfaceOfTypeWithCurrentIfaces(
		expanded_combo, requested_type)) {
		return true;
		}
		}
		@@ -1339,6 +1345,62 @@ bool WifiChip::canCurrentModeSupportIfaceOfType(IfaceType type) {
		return false;
		}

		// Note: This does not consider ifaces already active. It only checks if the
		// provided expanded iface combination can support the requested combo.
		bool WifiChip::canExpandedIfaceComboSupportIfaceCombo(
		const std::map<IfaceType, size_t>& expanded_combo,
		const std::map<IfaceType, size_t>& req_combo) {
		// Check if we have space for 1 more iface of \|type\| in this combo
		for (const auto type :
		{IfaceType::AP, IfaceType::NAN, IfaceType::P2P, IfaceType::STA}) {
		if (req_combo.count(type) == 0) {
		// Iface of "type" not in the req_combo.
		continue;
		}
		size_t num_ifaces_needed = req_combo.at(type);
		size_t num_ifaces_allowed = expanded_combo.at(type);
		if (num_ifaces_needed > num_ifaces_allowed) {
		return false;
		}
		}
		return true;
		}
		// This method does the following:
		// a) Enumerate all possible iface combos by expanding the current
		// ChipIfaceCombination.
		// b) Check if the requested iface combo can be added to the current mode.
		// Note: This does not consider ifaces already active. It only checks if the
		// current mode can support the requested combo.
		bool WifiChip::canCurrentModeSupportIfaceCombo(
		const std::map<IfaceType, size_t>& req_combo) {
		if (!isValidModeId(current_mode_id_)) {
		LOG(ERROR) << "Chip not configured in a mode yet";
		return false;
		}
		const auto combinations = getCurrentModeIfaceCombinations();
		for (const auto& combination : combinations) {
		const auto expanded_combos = expandIfaceCombinations(combination);
		for (const auto& expanded_combo : expanded_combos) {
		if (canExpandedIfaceComboSupportIfaceCombo(expanded_combo,
		req_combo)) {
		return true;
		}
		}
		}
		return false;
		}

		// This method does the following:
		// a) Enumerate all possible iface combos by expanding the current
		// ChipIfaceCombination.
		// b) Check if the requested iface type can be added to the current mode.
		bool WifiChip::canCurrentModeSupportIfaceOfType(IfaceType requested_type) {
		// Check if we can support atleast 1 iface of type.
		std::map<IfaceType, size_t> req_iface_combo;
		req_iface_combo[requested_type] = 1;
		return canCurrentModeSupportIfaceCombo(req_iface_combo);
		}

		bool WifiChip::isValidModeId(ChipModeId mode_id) {
		for (const auto& mode : modes_) {
		if (mode.id == mode_id) {
		@@ -1348,11 +1410,32 @@ bool WifiChip::isValidModeId(ChipModeId mode_id) {
		return false;
		}

		// Return the first wlan (wlan0, wlan1 etc.) not already in use.
		// This doesn't check the actual presence of these interfaces.
		std::string WifiChip::allocateApOrStaIfaceName() {
		for (unsigned i = 0; i < kMaxWlanIfaces; i++) {
		const auto ifname = getWlanIfaceName(i);
		bool WifiChip::isStaApConcurrencyAllowedInCurrentMode() {
		// Check if we can support atleast 1 STA & 1 AP concurrently.
		std::map<IfaceType, size_t> req_iface_combo;
		req_iface_combo[IfaceType::AP] = 1;
		req_iface_combo[IfaceType::STA] = 1;
		return canCurrentModeSupportIfaceCombo(req_iface_combo);
		}

		std::string WifiChip::getFirstActiveWlanIfaceName() {
		for (unsigned idx = 0; idx < kMaxWlanIfaces; idx++) {
		const auto ifname = getWlanIfaceName(idx);
		if (findUsingName(sta_ifaces_, ifname)) return ifname;
		if (findUsingName(ap_ifaces_, ifname)) return ifname;
		}
		// This could happen if the chip call is made before any STA/AP
		// iface is created. Default to wlan0 for such cases.
		LOG(WARNING) << "No active wlan interfaces in use!";
		return getWlanIfaceName(0);
		}

		// Return the first wlan (wlan0, wlan1 etc.) starting from \|start_idx\|
		// not already in use.
		// Note: This doesn't check the actual presence of these interfaces.
		std::string WifiChip::allocateApOrStaIfaceName(uint32_t start_idx) {
		for (unsigned idx = start_idx; idx < kMaxWlanIfaces; idx++) {
		const auto ifname = getWlanIfaceName(idx);
		if (findUsingName(ap_ifaces_, ifname)) continue;
		if (findUsingName(sta_ifaces_, ifname)) continue;
		return ifname;
		@@ -1362,6 +1445,19 @@ std::string WifiChip::allocateApOrStaIfaceName() {
		return {};
		}

		// AP iface names start with idx 1 for modes supporting
		// concurrent STA, else start with idx 0.
		std::string WifiChip::allocateApIfaceName() {
		return allocateApOrStaIfaceName(
		isStaApConcurrencyAllowedInCurrentMode() ? 1 : 0);
		}

		// STA iface names start with idx 0.
		// Primary STA iface will always be 0.
		std::string WifiChip::allocateStaIfaceName() {
		return allocateApOrStaIfaceName(0);
		}

		bool WifiChip::writeRingbufferFilesInternal() {
		if (!removeOldFilesInternal()) {
		LOG(ERROR) << "Error occurred while deleting old tombstone files";

wifi/1.3/default/wifi_chip.h

+16 −4

File changed.

Preview size limit exceeded, changes collapsed.

wifi/1.3/default/wifi_legacy_hal.h

+3 −3

File changed.

Preview size limit exceeded, changes collapsed.