blob: d6106b47f95fb287eb7f0a2ebc84abefee8d9c34 [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 {
24// Chip ID to use for the only supported chip.
25static constexpr android::hardware::wifi::V1_0::ChipId kChipId = 0;
26} // namespace
27
Roshan Pius3c4e8a32016-10-03 14:53:58 -070028namespace android {
29namespace hardware {
30namespace wifi {
Etan Cohen6ce50902017-09-14 07:30:57 -070031namespace V1_2 {
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(
37 const std::shared_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
38 const std::shared_ptr<mode_controller::WifiModeController> mode_controller,
39 const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags)
40 : legacy_hal_(legacy_hal),
41 mode_controller_(mode_controller),
42 feature_flags_(feature_flags),
Roshan Pius6cedc972016-10-28 10:11:17 -070043 run_state_(RunState::STOPPED) {}
Roshan Pius3c4e8a32016-10-03 14:53:58 -070044
Roshan Pius56476652016-10-26 14:43:05 -070045bool Wifi::isValid() {
Roshan Piusabcf78f2017-10-06 16:30:38 -070046 // This object is always valid.
47 return true;
Roshan Pius56476652016-10-26 14:43:05 -070048}
49
Roshan Pius3c4e8a32016-10-03 14:53:58 -070050Return<void> Wifi::registerEventCallback(
Roshan Pius56476652016-10-26 14:43:05 -070051 const sp<IWifiEventCallback>& event_callback,
52 registerEventCallback_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070053 return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
54 &Wifi::registerEventCallbackInternal, hidl_status_cb,
55 event_callback);
Roshan Pius3c4e8a32016-10-03 14:53:58 -070056}
57
Roshan Piusabcf78f2017-10-06 16:30:38 -070058Return<bool> Wifi::isStarted() { return run_state_ != RunState::STOPPED; }
Roshan Pius3c4e8a32016-10-03 14:53:58 -070059
Roshan Pius503582e2016-10-11 08:25:30 -070060Return<void> Wifi::start(start_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070061 return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
62 &Wifi::startInternal, hidl_status_cb);
Roshan Pius56476652016-10-26 14:43:05 -070063}
64
65Return<void> Wifi::stop(stop_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070066 return validateAndCallWithLock(this, WifiStatusCode::ERROR_UNKNOWN,
67 &Wifi::stopInternal, hidl_status_cb);
Roshan Pius56476652016-10-26 14:43:05 -070068}
69
70Return<void> Wifi::getChipIds(getChipIds_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070071 return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
72 &Wifi::getChipIdsInternal, hidl_status_cb);
Roshan Pius56476652016-10-26 14:43:05 -070073}
74
75Return<void> Wifi::getChip(ChipId chip_id, getChip_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070076 return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
77 &Wifi::getChipInternal, hidl_status_cb, chip_id);
Roshan Pius56476652016-10-26 14:43:05 -070078}
79
xshu5899e8e2018-01-09 15:36:03 -080080Return<void> Wifi::debug(const hidl_handle& handle,
81 const hidl_vec<hidl_string>&) {
82 LOG(INFO) << "-----------Debug is called----------------";
83 return chip_->debug(handle, {});
84}
85
Roshan Pius56476652016-10-26 14:43:05 -070086WifiStatus Wifi::registerEventCallbackInternal(
87 const sp<IWifiEventCallback>& event_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070088 if (!event_cb_handler_.addCallback(event_callback)) {
89 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
90 }
91 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius56476652016-10-26 14:43:05 -070092}
93
94WifiStatus Wifi::startInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -070095 if (run_state_ == RunState::STARTED) {
96 return createWifiStatus(WifiStatusCode::SUCCESS);
97 } else if (run_state_ == RunState::STOPPING) {
98 return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE,
99 "HAL is stopping");
Roshan Pius52947fb2016-11-18 11:38:07 -0800100 }
Roshan Pius8fc6d172017-11-27 16:08:27 -0800101 WifiStatus wifi_status = initializeModeControllerAndLegacyHal();
Roshan Piusabcf78f2017-10-06 16:30:38 -0700102 if (wifi_status.code == WifiStatusCode::SUCCESS) {
103 // Create the chip instance once the HAL is started.
Roshan Pius200a17d2017-11-01 13:03:35 -0700104 chip_ = new WifiChip(kChipId, legacy_hal_, mode_controller_,
105 feature_flags_);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700106 run_state_ = RunState::STARTED;
107 for (const auto& callback : event_cb_handler_.getCallbacks()) {
108 if (!callback->onStart().isOk()) {
109 LOG(ERROR) << "Failed to invoke onStart callback";
110 };
111 }
112 LOG(INFO) << "Wifi HAL started";
113 } else {
114 for (const auto& callback : event_cb_handler_.getCallbacks()) {
115 if (!callback->onFailure(wifi_status).isOk()) {
116 LOG(ERROR) << "Failed to invoke onFailure callback";
117 }
118 }
119 LOG(ERROR) << "Wifi HAL start failed";
Roshan Pius52947fb2016-11-18 11:38:07 -0800120 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700121 return wifi_status;
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700122}
123
Roshan Pius155344b2017-08-11 15:47:42 -0700124WifiStatus Wifi::stopInternal(
125 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700126 if (run_state_ == RunState::STOPPED) {
127 return createWifiStatus(WifiStatusCode::SUCCESS);
128 } else if (run_state_ == RunState::STOPPING) {
129 return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE,
130 "HAL is stopping");
Roshan Piusaabe5752016-09-29 09:03:59 -0700131 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700132 // Clear the chip object and its child objects since the HAL is now
133 // stopped.
134 if (chip_.get()) {
135 chip_->invalidate();
136 chip_.clear();
Roshan Piusaabe5752016-09-29 09:03:59 -0700137 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700138 WifiStatus wifi_status = stopLegacyHalAndDeinitializeModeController(lock);
139 if (wifi_status.code == WifiStatusCode::SUCCESS) {
140 for (const auto& callback : event_cb_handler_.getCallbacks()) {
141 if (!callback->onStop().isOk()) {
142 LOG(ERROR) << "Failed to invoke onStop callback";
143 };
144 }
145 LOG(INFO) << "Wifi HAL stopped";
146 } else {
147 for (const auto& callback : event_cb_handler_.getCallbacks()) {
148 if (!callback->onFailure(wifi_status).isOk()) {
149 LOG(ERROR) << "Failed to invoke onFailure callback";
150 }
151 }
152 LOG(ERROR) << "Wifi HAL stop failed";
153 }
154 return wifi_status;
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700155}
156
Roshan Pius56476652016-10-26 14:43:05 -0700157std::pair<WifiStatus, std::vector<ChipId>> Wifi::getChipIdsInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700158 std::vector<ChipId> chip_ids;
159 if (chip_.get()) {
160 chip_ids.emplace_back(kChipId);
161 }
162 return {createWifiStatus(WifiStatusCode::SUCCESS), std::move(chip_ids)};
Roshan Piuscd566bd2016-10-10 08:03:42 -0700163}
164
Roshan Pius56476652016-10-26 14:43:05 -0700165std::pair<WifiStatus, sp<IWifiChip>> Wifi::getChipInternal(ChipId chip_id) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700166 if (!chip_.get()) {
167 return {createWifiStatus(WifiStatusCode::ERROR_NOT_STARTED), nullptr};
168 }
169 if (chip_id != kChipId) {
170 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
171 }
172 return {createWifiStatus(WifiStatusCode::SUCCESS), chip_};
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700173}
Roshan Pius52947fb2016-11-18 11:38:07 -0800174
Roshan Pius8fc6d172017-11-27 16:08:27 -0800175WifiStatus Wifi::initializeModeControllerAndLegacyHal() {
176 if (!mode_controller_->initialize()) {
177 LOG(ERROR) << "Failed to initialize firmware mode controller";
178 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
179 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700180 legacy_hal::wifi_error legacy_status = legacy_hal_->initialize();
181 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
182 LOG(ERROR) << "Failed to initialize legacy HAL: "
183 << legacyErrorToString(legacy_status);
184 return createWifiStatusFromLegacyError(legacy_status);
185 }
186 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius52947fb2016-11-18 11:38:07 -0800187}
188
Roshan Pius155344b2017-08-11 15:47:42 -0700189WifiStatus Wifi::stopLegacyHalAndDeinitializeModeController(
190 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700191 run_state_ = RunState::STOPPING;
192 legacy_hal::wifi_error legacy_status =
193 legacy_hal_->stop(lock, [&]() { run_state_ = RunState::STOPPED; });
194 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
195 LOG(ERROR) << "Failed to stop legacy HAL: "
196 << legacyErrorToString(legacy_status);
197 return createWifiStatusFromLegacyError(legacy_status);
198 }
199 if (!mode_controller_->deinitialize()) {
200 LOG(ERROR) << "Failed to deinitialize firmware mode controller";
201 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
202 }
203 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius52947fb2016-11-18 11:38:07 -0800204}
Roshan Pius79a99752016-10-04 13:03:58 -0700205} // namespace implementation
Etan Cohen6ce50902017-09-14 07:30:57 -0700206} // namespace V1_2
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700207} // namespace wifi
208} // namespace hardware
209} // namespace android