blob: da98db829688131b7ec71f86c08a1fdd38e5c269 [file] [log] [blame]
Roshan Pius3c4e8a32016-10-03 14:53:58 -07001/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Roshan Pius3c4e8a32016-10-03 14:53:58 -070017#include <android-base/logging.h>
Roshan Pius3c4e8a32016-10-03 14:53:58 -070018
Roshan Pius56476652016-10-26 14:43:05 -070019#include "hidl_return_util.h"
20#include "wifi.h"
Roshan Pius503582e2016-10-11 08:25:30 -070021#include "wifi_status_util.h"
Roshan Pius3c4e8a32016-10-03 14:53:58 -070022
Roshan Piuscd566bd2016-10-10 08:03:42 -070023namespace {
Jimmy Chen2dddd792019-12-23 17:50:39 +020024// Starting Chip ID, will be assigned to primary chip
25static constexpr android::hardware::wifi::V1_0::ChipId kPrimaryChipId = 0;
Roshan Piuscd566bd2016-10-10 08:03:42 -070026} // namespace
27
Roshan Pius3c4e8a32016-10-03 14:53:58 -070028namespace android {
29namespace hardware {
30namespace wifi {
Jimmy Chend460df32019-11-29 17:31:22 +020031namespace V1_5 {
Roshan Pius79a99752016-10-04 13:03:58 -070032namespace implementation {
Roshan Pius56476652016-10-26 14:43:05 -070033using hidl_return_util::validateAndCall;
Roshan Pius155344b2017-08-11 15:47:42 -070034using hidl_return_util::validateAndCallWithLock;
Roshan Pius3c4e8a32016-10-03 14:53:58 -070035
Roshan Pius200a17d2017-11-01 13:03:35 -070036Wifi::Wifi(
Roshan Piusc885df02019-05-21 14:49:05 -070037 const std::shared_ptr<wifi_system::InterfaceTool> iface_tool,
Jimmy Chen2dddd792019-12-23 17:50:39 +020038 const std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory,
Roshan Pius200a17d2017-11-01 13:03:35 -070039 const std::shared_ptr<mode_controller::WifiModeController> mode_controller,
40 const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags)
Roshan Piusc885df02019-05-21 14:49:05 -070041 : iface_tool_(iface_tool),
Jimmy Chen2dddd792019-12-23 17:50:39 +020042 legacy_hal_factory_(legacy_hal_factory),
Roshan Pius200a17d2017-11-01 13:03:35 -070043 mode_controller_(mode_controller),
44 feature_flags_(feature_flags),
Roshan Pius6cedc972016-10-28 10:11:17 -070045 run_state_(RunState::STOPPED) {}
Roshan Pius3c4e8a32016-10-03 14:53:58 -070046
Roshan Pius56476652016-10-26 14:43:05 -070047bool Wifi::isValid() {
Roshan Piusabcf78f2017-10-06 16:30:38 -070048 // This object is always valid.
49 return true;
Roshan Pius56476652016-10-26 14:43:05 -070050}
51
Roshan Pius3c4e8a32016-10-03 14:53:58 -070052Return<void> Wifi::registerEventCallback(
Roshan Pius56476652016-10-26 14:43:05 -070053 const sp<IWifiEventCallback>& event_callback,
54 registerEventCallback_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070055 return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
56 &Wifi::registerEventCallbackInternal, hidl_status_cb,
57 event_callback);
Roshan Pius3c4e8a32016-10-03 14:53:58 -070058}
59
Roshan Piusabcf78f2017-10-06 16:30:38 -070060Return<bool> Wifi::isStarted() { return run_state_ != RunState::STOPPED; }
Roshan Pius3c4e8a32016-10-03 14:53:58 -070061
Roshan Pius503582e2016-10-11 08:25:30 -070062Return<void> Wifi::start(start_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070063 return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
64 &Wifi::startInternal, hidl_status_cb);
Roshan Pius56476652016-10-26 14:43:05 -070065}
66
67Return<void> Wifi::stop(stop_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070068 return validateAndCallWithLock(this, WifiStatusCode::ERROR_UNKNOWN,
69 &Wifi::stopInternal, hidl_status_cb);
Roshan Pius56476652016-10-26 14:43:05 -070070}
71
72Return<void> Wifi::getChipIds(getChipIds_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070073 return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
74 &Wifi::getChipIdsInternal, hidl_status_cb);
Roshan Pius56476652016-10-26 14:43:05 -070075}
76
77Return<void> Wifi::getChip(ChipId chip_id, getChip_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070078 return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
79 &Wifi::getChipInternal, hidl_status_cb, chip_id);
Roshan Pius56476652016-10-26 14:43:05 -070080}
81
xshu5899e8e2018-01-09 15:36:03 -080082Return<void> Wifi::debug(const hidl_handle& handle,
83 const hidl_vec<hidl_string>&) {
84 LOG(INFO) << "-----------Debug is called----------------";
Jimmy Chen2dddd792019-12-23 17:50:39 +020085 if (chips_.size() == 0) {
Roshan Pius7cf1df72018-01-24 19:13:09 -080086 return Void();
87 }
Jimmy Chen2dddd792019-12-23 17:50:39 +020088
89 for (sp<WifiChip> chip : chips_) {
90 if (!chip.get()) continue;
91
92 chip->debug(handle, {});
93 }
94 return Void();
xshu5899e8e2018-01-09 15:36:03 -080095}
96
Roshan Pius56476652016-10-26 14:43:05 -070097WifiStatus Wifi::registerEventCallbackInternal(
98 const sp<IWifiEventCallback>& event_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070099 if (!event_cb_handler_.addCallback(event_callback)) {
100 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
101 }
102 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius56476652016-10-26 14:43:05 -0700103}
104
105WifiStatus Wifi::startInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700106 if (run_state_ == RunState::STARTED) {
107 return createWifiStatus(WifiStatusCode::SUCCESS);
108 } else if (run_state_ == RunState::STOPPING) {
109 return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE,
110 "HAL is stopping");
Roshan Pius52947fb2016-11-18 11:38:07 -0800111 }
Roshan Pius8fc6d172017-11-27 16:08:27 -0800112 WifiStatus wifi_status = initializeModeControllerAndLegacyHal();
Roshan Piusabcf78f2017-10-06 16:30:38 -0700113 if (wifi_status.code == WifiStatusCode::SUCCESS) {
Ahmed ElArabawy2134bf72020-06-18 15:07:12 -0700114 // Register the callback for subsystem restart
115 const auto& on_subsystem_restart_callback =
116 [this](const std::string& error) {
117 WifiStatus wifi_status =
118 createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, error);
119 for (const auto& callback : event_cb_handler_.getCallbacks()) {
120 if (!callback->onFailure(wifi_status).isOk()) {
121 LOG(ERROR) << "Failed to invoke onFailure callback";
122 }
123 }
124 };
125
Roshan Piusabcf78f2017-10-06 16:30:38 -0700126 // Create the chip instance once the HAL is started.
Jimmy Chen2dddd792019-12-23 17:50:39 +0200127 android::hardware::wifi::V1_0::ChipId chipId = kPrimaryChipId;
128 for (auto& hal : legacy_hals_) {
129 chips_.push_back(new WifiChip(
130 chipId, chipId == kPrimaryChipId, hal, mode_controller_,
Roshan Pius8c1a67b2021-03-02 10:00:23 -0800131 std::make_shared<iface_util::WifiIfaceUtil>(iface_tool_, hal),
132 feature_flags_, on_subsystem_restart_callback));
Jimmy Chen2dddd792019-12-23 17:50:39 +0200133 chipId++;
134 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700135 run_state_ = RunState::STARTED;
136 for (const auto& callback : event_cb_handler_.getCallbacks()) {
137 if (!callback->onStart().isOk()) {
138 LOG(ERROR) << "Failed to invoke onStart callback";
139 };
140 }
141 LOG(INFO) << "Wifi HAL started";
142 } else {
143 for (const auto& callback : event_cb_handler_.getCallbacks()) {
144 if (!callback->onFailure(wifi_status).isOk()) {
145 LOG(ERROR) << "Failed to invoke onFailure callback";
146 }
147 }
148 LOG(ERROR) << "Wifi HAL start failed";
Kyounghan Leef2e21c22020-01-29 14:56:15 +0900149 // Clear the event callback objects since the HAL start failed.
150 event_cb_handler_.invalidate();
Roshan Pius52947fb2016-11-18 11:38:07 -0800151 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700152 return wifi_status;
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700153}
154
Roshan Pius155344b2017-08-11 15:47:42 -0700155WifiStatus Wifi::stopInternal(
156 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700157 if (run_state_ == RunState::STOPPED) {
158 return createWifiStatus(WifiStatusCode::SUCCESS);
159 } else if (run_state_ == RunState::STOPPING) {
160 return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE,
161 "HAL is stopping");
Roshan Piusaabe5752016-09-29 09:03:59 -0700162 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700163 // Clear the chip object and its child objects since the HAL is now
164 // stopped.
Jimmy Chen2dddd792019-12-23 17:50:39 +0200165 for (auto& chip : chips_) {
166 if (chip.get()) {
167 chip->invalidate();
168 chip.clear();
169 }
Roshan Piusaabe5752016-09-29 09:03:59 -0700170 }
Jimmy Chen2dddd792019-12-23 17:50:39 +0200171 chips_.clear();
Roshan Piusabcf78f2017-10-06 16:30:38 -0700172 WifiStatus wifi_status = stopLegacyHalAndDeinitializeModeController(lock);
173 if (wifi_status.code == WifiStatusCode::SUCCESS) {
174 for (const auto& callback : event_cb_handler_.getCallbacks()) {
175 if (!callback->onStop().isOk()) {
176 LOG(ERROR) << "Failed to invoke onStop callback";
177 };
178 }
179 LOG(INFO) << "Wifi HAL stopped";
180 } else {
181 for (const auto& callback : event_cb_handler_.getCallbacks()) {
182 if (!callback->onFailure(wifi_status).isOk()) {
183 LOG(ERROR) << "Failed to invoke onFailure callback";
184 }
185 }
186 LOG(ERROR) << "Wifi HAL stop failed";
187 }
Kyounghan Leef2e21c22020-01-29 14:56:15 +0900188 // Clear the event callback objects since the HAL is now stopped.
189 event_cb_handler_.invalidate();
Roshan Piusabcf78f2017-10-06 16:30:38 -0700190 return wifi_status;
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700191}
192
Roshan Pius56476652016-10-26 14:43:05 -0700193std::pair<WifiStatus, std::vector<ChipId>> Wifi::getChipIdsInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700194 std::vector<ChipId> chip_ids;
Jimmy Chen2dddd792019-12-23 17:50:39 +0200195
196 for (auto& chip : chips_) {
197 ChipId chip_id = getChipIdFromWifiChip(chip);
198 if (chip_id != UINT32_MAX) chip_ids.emplace_back(chip_id);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700199 }
200 return {createWifiStatus(WifiStatusCode::SUCCESS), std::move(chip_ids)};
Roshan Piuscd566bd2016-10-10 08:03:42 -0700201}
202
Jimmy Chend460df32019-11-29 17:31:22 +0200203std::pair<WifiStatus, sp<V1_4::IWifiChip>> Wifi::getChipInternal(
204 ChipId chip_id) {
Jimmy Chen2dddd792019-12-23 17:50:39 +0200205 for (auto& chip : chips_) {
206 ChipId cand_id = getChipIdFromWifiChip(chip);
207 if ((cand_id != UINT32_MAX) && (cand_id == chip_id))
208 return {createWifiStatus(WifiStatusCode::SUCCESS), chip};
Roshan Piusabcf78f2017-10-06 16:30:38 -0700209 }
Jimmy Chen2dddd792019-12-23 17:50:39 +0200210
211 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700212}
Roshan Pius52947fb2016-11-18 11:38:07 -0800213
Roshan Pius8fc6d172017-11-27 16:08:27 -0800214WifiStatus Wifi::initializeModeControllerAndLegacyHal() {
215 if (!mode_controller_->initialize()) {
216 LOG(ERROR) << "Failed to initialize firmware mode controller";
217 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
218 }
Jimmy Chen2dddd792019-12-23 17:50:39 +0200219
220 legacy_hals_ = legacy_hal_factory_->getHals();
221 if (legacy_hals_.empty())
222 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
223 int index = 0; // for failure log
224 for (auto& hal : legacy_hals_) {
225 legacy_hal::wifi_error legacy_status = hal->initialize();
226 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
227 // Currently WifiLegacyHal::initialize does not allocate extra mem,
228 // only initializes the function table. If this changes, need to
229 // implement WifiLegacyHal::deinitialize and deinitalize the
230 // HALs already initialized
231 LOG(ERROR) << "Failed to initialize legacy HAL index: " << index
232 << " error: " << legacyErrorToString(legacy_status);
233 return createWifiStatusFromLegacyError(legacy_status);
234 }
235 index++;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700236 }
237 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius52947fb2016-11-18 11:38:07 -0800238}
239
Roshan Pius155344b2017-08-11 15:47:42 -0700240WifiStatus Wifi::stopLegacyHalAndDeinitializeModeController(
241 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
Jimmy Chen2dddd792019-12-23 17:50:39 +0200242 legacy_hal::wifi_error legacy_status = legacy_hal::WIFI_SUCCESS;
243 int index = 0;
244
Roshan Piusabcf78f2017-10-06 16:30:38 -0700245 run_state_ = RunState::STOPPING;
Jimmy Chen2dddd792019-12-23 17:50:39 +0200246 for (auto& hal : legacy_hals_) {
247 legacy_hal::wifi_error tmp = hal->stop(lock, [&]() {});
248 if (tmp != legacy_hal::WIFI_SUCCESS) {
249 LOG(ERROR) << "Failed to stop legacy HAL index: " << index
250 << " error: " << legacyErrorToString(legacy_status);
251 legacy_status = tmp;
252 }
253 index++;
254 }
255 run_state_ = RunState::STOPPED;
256
Roshan Piusabcf78f2017-10-06 16:30:38 -0700257 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
Jimmy Chen2dddd792019-12-23 17:50:39 +0200258 LOG(ERROR) << "One or more legacy HALs failed to stop";
Roshan Piusabcf78f2017-10-06 16:30:38 -0700259 return createWifiStatusFromLegacyError(legacy_status);
260 }
261 if (!mode_controller_->deinitialize()) {
262 LOG(ERROR) << "Failed to deinitialize firmware mode controller";
263 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
264 }
265 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius52947fb2016-11-18 11:38:07 -0800266}
Jimmy Chen2dddd792019-12-23 17:50:39 +0200267
268ChipId Wifi::getChipIdFromWifiChip(sp<WifiChip>& chip) {
269 ChipId chip_id = UINT32_MAX;
270 if (chip.get()) {
271 chip->getId([&](WifiStatus status, uint32_t id) {
272 if (status.code == WifiStatusCode::SUCCESS) {
273 chip_id = id;
274 }
275 });
276 }
277
278 return chip_id;
279}
Roshan Pius79a99752016-10-04 13:03:58 -0700280} // namespace implementation
Jimmy Chend460df32019-11-29 17:31:22 +0200281} // namespace V1_5
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700282} // namespace wifi
283} // namespace hardware
284} // namespace android