1 /*
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
17 #include <android-base/logging.h>
18
19 #include "hidl_return_util.h"
20 #include "wifi.h"
21 #include "wifi_status_util.h"
22
23 namespace {
24 // Starting Chip ID, will be assigned to primary chip
25 static constexpr android::hardware::wifi::V1_0::ChipId kPrimaryChipId = 0;
26 } // namespace
27
28 namespace android {
29 namespace hardware {
30 namespace wifi {
31 namespace V1_5 {
32 namespace implementation {
33 using hidl_return_util::validateAndCall;
34 using hidl_return_util::validateAndCallWithLock;
35
Wifi(const std::shared_ptr<wifi_system::InterfaceTool> iface_tool,const std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory,const std::shared_ptr<mode_controller::WifiModeController> mode_controller,const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags)36 Wifi::Wifi(
37 const std::shared_ptr<wifi_system::InterfaceTool> iface_tool,
38 const std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory,
39 const std::shared_ptr<mode_controller::WifiModeController> mode_controller,
40 const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags)
41 : iface_tool_(iface_tool),
42 legacy_hal_factory_(legacy_hal_factory),
43 mode_controller_(mode_controller),
44 feature_flags_(feature_flags),
45 run_state_(RunState::STOPPED) {}
46
isValid()47 bool Wifi::isValid() {
48 // This object is always valid.
49 return true;
50 }
51
registerEventCallback(const sp<V1_0::IWifiEventCallback> & event_callback,registerEventCallback_cb hidl_status_cb)52 Return<void> Wifi::registerEventCallback(
53 const sp<V1_0::IWifiEventCallback>& event_callback,
54 registerEventCallback_cb hidl_status_cb) {
55 return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
56 &Wifi::registerEventCallbackInternal, hidl_status_cb,
57 event_callback);
58 }
59
registerEventCallback_1_5(const sp<V1_5::IWifiEventCallback> & event_callback,registerEventCallback_1_5_cb hidl_status_cb)60 Return<void> Wifi::registerEventCallback_1_5(
61 const sp<V1_5::IWifiEventCallback>& event_callback,
62 registerEventCallback_1_5_cb hidl_status_cb) {
63 return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
64 &Wifi::registerEventCallbackInternal_1_5,
65 hidl_status_cb, event_callback);
66 }
67
isStarted()68 Return<bool> Wifi::isStarted() { return run_state_ != RunState::STOPPED; }
69
start(start_cb hidl_status_cb)70 Return<void> Wifi::start(start_cb hidl_status_cb) {
71 return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
72 &Wifi::startInternal, hidl_status_cb);
73 }
74
stop(stop_cb hidl_status_cb)75 Return<void> Wifi::stop(stop_cb hidl_status_cb) {
76 return validateAndCallWithLock(this, WifiStatusCode::ERROR_UNKNOWN,
77 &Wifi::stopInternal, hidl_status_cb);
78 }
79
getChipIds(getChipIds_cb hidl_status_cb)80 Return<void> Wifi::getChipIds(getChipIds_cb hidl_status_cb) {
81 return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
82 &Wifi::getChipIdsInternal, hidl_status_cb);
83 }
84
getChip(ChipId chip_id,getChip_cb hidl_status_cb)85 Return<void> Wifi::getChip(ChipId chip_id, getChip_cb hidl_status_cb) {
86 return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
87 &Wifi::getChipInternal, hidl_status_cb, chip_id);
88 }
89
debug(const hidl_handle & handle,const hidl_vec<hidl_string> &)90 Return<void> Wifi::debug(const hidl_handle& handle,
91 const hidl_vec<hidl_string>&) {
92 LOG(INFO) << "-----------Debug is called----------------";
93 if (chips_.size() == 0) {
94 return Void();
95 }
96
97 for (sp<WifiChip> chip : chips_) {
98 if (!chip.get()) continue;
99
100 chip->debug(handle, {});
101 }
102 return Void();
103 }
104
registerEventCallbackInternal(const sp<V1_0::IWifiEventCallback> & event_callback __unused)105 WifiStatus Wifi::registerEventCallbackInternal(
106 const sp<V1_0::IWifiEventCallback>& event_callback __unused) {
107 // Deprecated support for this callback.
108 return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
109 }
110
registerEventCallbackInternal_1_5(const sp<V1_5::IWifiEventCallback> & event_callback)111 WifiStatus Wifi::registerEventCallbackInternal_1_5(
112 const sp<V1_5::IWifiEventCallback>& event_callback) {
113 if (!event_cb_handler_.addCallback(event_callback)) {
114 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
115 }
116 return createWifiStatus(WifiStatusCode::SUCCESS);
117 }
118
startInternal()119 WifiStatus Wifi::startInternal() {
120 if (run_state_ == RunState::STARTED) {
121 return createWifiStatus(WifiStatusCode::SUCCESS);
122 } else if (run_state_ == RunState::STOPPING) {
123 return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE,
124 "HAL is stopping");
125 }
126 WifiStatus wifi_status = initializeModeControllerAndLegacyHal();
127 if (wifi_status.code == WifiStatusCode::SUCCESS) {
128 // Register the callback for subsystem restart
129 const auto& on_subsystem_restart_callback =
130 [this](const std::string& error) {
131 WifiStatus wifi_status =
132 createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, error);
133 for (const auto& callback : event_cb_handler_.getCallbacks()) {
134 LOG(INFO) << "Attempting to invoke onSubsystemRestart "
135 "callback";
136 if (!callback->onSubsystemRestart(wifi_status).isOk()) {
137 LOG(ERROR)
138 << "Failed to invoke onSubsystemRestart callback";
139 } else {
140 LOG(INFO) << "Succeeded to invoke onSubsystemRestart "
141 "callback";
142 }
143 }
144 };
145
146 // Create the chip instance once the HAL is started.
147 android::hardware::wifi::V1_0::ChipId chipId = kPrimaryChipId;
148 for (auto& hal : legacy_hals_) {
149 chips_.push_back(new WifiChip(
150 chipId, chipId == kPrimaryChipId, hal, mode_controller_,
151 std::make_shared<iface_util::WifiIfaceUtil>(iface_tool_, hal),
152 feature_flags_, on_subsystem_restart_callback));
153 chipId++;
154 }
155 run_state_ = RunState::STARTED;
156 for (const auto& callback : event_cb_handler_.getCallbacks()) {
157 if (!callback->onStart().isOk()) {
158 LOG(ERROR) << "Failed to invoke onStart callback";
159 };
160 }
161 LOG(INFO) << "Wifi HAL started";
162 } else {
163 for (const auto& callback : event_cb_handler_.getCallbacks()) {
164 if (!callback->onFailure(wifi_status).isOk()) {
165 LOG(ERROR) << "Failed to invoke onFailure callback";
166 }
167 }
168 LOG(ERROR) << "Wifi HAL start failed";
169 // Clear the event callback objects since the HAL start failed.
170 event_cb_handler_.invalidate();
171 }
172 return wifi_status;
173 }
174
stopInternal(std::unique_lock<std::recursive_mutex> * lock)175 WifiStatus Wifi::stopInternal(
176 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
177 if (run_state_ == RunState::STOPPED) {
178 return createWifiStatus(WifiStatusCode::SUCCESS);
179 } else if (run_state_ == RunState::STOPPING) {
180 return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE,
181 "HAL is stopping");
182 }
183 // Clear the chip object and its child objects since the HAL is now
184 // stopped.
185 for (auto& chip : chips_) {
186 if (chip.get()) {
187 chip->invalidate();
188 chip.clear();
189 }
190 }
191 chips_.clear();
192 WifiStatus wifi_status = stopLegacyHalAndDeinitializeModeController(lock);
193 if (wifi_status.code == WifiStatusCode::SUCCESS) {
194 for (const auto& callback : event_cb_handler_.getCallbacks()) {
195 if (!callback->onStop().isOk()) {
196 LOG(ERROR) << "Failed to invoke onStop callback";
197 };
198 }
199 LOG(INFO) << "Wifi HAL stopped";
200 } else {
201 for (const auto& callback : event_cb_handler_.getCallbacks()) {
202 if (!callback->onFailure(wifi_status).isOk()) {
203 LOG(ERROR) << "Failed to invoke onFailure callback";
204 }
205 }
206 LOG(ERROR) << "Wifi HAL stop failed";
207 }
208 // Clear the event callback objects since the HAL is now stopped.
209 event_cb_handler_.invalidate();
210 return wifi_status;
211 }
212
getChipIdsInternal()213 std::pair<WifiStatus, std::vector<ChipId>> Wifi::getChipIdsInternal() {
214 std::vector<ChipId> chip_ids;
215
216 for (auto& chip : chips_) {
217 ChipId chip_id = getChipIdFromWifiChip(chip);
218 if (chip_id != UINT32_MAX) chip_ids.emplace_back(chip_id);
219 }
220 return {createWifiStatus(WifiStatusCode::SUCCESS), std::move(chip_ids)};
221 }
222
getChipInternal(ChipId chip_id)223 std::pair<WifiStatus, sp<V1_4::IWifiChip>> Wifi::getChipInternal(
224 ChipId chip_id) {
225 for (auto& chip : chips_) {
226 ChipId cand_id = getChipIdFromWifiChip(chip);
227 if ((cand_id != UINT32_MAX) && (cand_id == chip_id))
228 return {createWifiStatus(WifiStatusCode::SUCCESS), chip};
229 }
230
231 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
232 }
233
initializeModeControllerAndLegacyHal()234 WifiStatus Wifi::initializeModeControllerAndLegacyHal() {
235 if (!mode_controller_->initialize()) {
236 LOG(ERROR) << "Failed to initialize firmware mode controller";
237 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
238 }
239
240 legacy_hals_ = legacy_hal_factory_->getHals();
241 if (legacy_hals_.empty())
242 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
243 int index = 0; // for failure log
244 for (auto& hal : legacy_hals_) {
245 legacy_hal::wifi_error legacy_status = hal->initialize();
246 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
247 // Currently WifiLegacyHal::initialize does not allocate extra mem,
248 // only initializes the function table. If this changes, need to
249 // implement WifiLegacyHal::deinitialize and deinitalize the
250 // HALs already initialized
251 LOG(ERROR) << "Failed to initialize legacy HAL index: " << index
252 << " error: " << legacyErrorToString(legacy_status);
253 return createWifiStatusFromLegacyError(legacy_status);
254 }
255 index++;
256 }
257 return createWifiStatus(WifiStatusCode::SUCCESS);
258 }
259
stopLegacyHalAndDeinitializeModeController(std::unique_lock<std::recursive_mutex> * lock)260 WifiStatus Wifi::stopLegacyHalAndDeinitializeModeController(
261 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
262 legacy_hal::wifi_error legacy_status = legacy_hal::WIFI_SUCCESS;
263 int index = 0;
264
265 run_state_ = RunState::STOPPING;
266 for (auto& hal : legacy_hals_) {
267 legacy_hal::wifi_error tmp = hal->stop(lock, [&]() {});
268 if (tmp != legacy_hal::WIFI_SUCCESS) {
269 LOG(ERROR) << "Failed to stop legacy HAL index: " << index
270 << " error: " << legacyErrorToString(legacy_status);
271 legacy_status = tmp;
272 }
273 index++;
274 }
275 run_state_ = RunState::STOPPED;
276
277 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
278 LOG(ERROR) << "One or more legacy HALs failed to stop";
279 return createWifiStatusFromLegacyError(legacy_status);
280 }
281 if (!mode_controller_->deinitialize()) {
282 LOG(ERROR) << "Failed to deinitialize firmware mode controller";
283 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
284 }
285 return createWifiStatus(WifiStatusCode::SUCCESS);
286 }
287
getChipIdFromWifiChip(sp<WifiChip> & chip)288 ChipId Wifi::getChipIdFromWifiChip(sp<WifiChip>& chip) {
289 ChipId chip_id = UINT32_MAX;
290 if (chip.get()) {
291 chip->getId([&](WifiStatus status, uint32_t id) {
292 if (status.code == WifiStatusCode::SUCCESS) {
293 chip_id = id;
294 }
295 });
296 }
297
298 return chip_id;
299 }
300 } // namespace implementation
301 } // namespace V1_5
302 } // namespace wifi
303 } // namespace hardware
304 } // namespace android
305