blob: b91a9461e04b95ff144a7c7e4245115a32b76b25 [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
xshu5899e8e2018-01-09 15:36:03 -080017#include <fcntl.h>
18
Roshan Pius3c4e8a32016-10-03 14:53:58 -070019#include <android-base/logging.h>
xshu5899e8e2018-01-09 15:36:03 -080020#include <android-base/unique_fd.h>
Roshan Pius9377a0d2017-10-06 13:18:54 -070021#include <cutils/properties.h>
xshu5899e8e2018-01-09 15:36:03 -080022#include <sys/stat.h>
23#include <sys/sysmacros.h>
Roshan Pius3c4e8a32016-10-03 14:53:58 -070024
Roshan Pius3c868522016-10-27 12:43:49 -070025#include "hidl_return_util.h"
Roshan Piuse2d0ab52016-12-05 15:24:20 -080026#include "hidl_struct_util.h"
Roshan Pius3c868522016-10-27 12:43:49 -070027#include "wifi_chip.h"
Roshan Pius5c055462016-10-11 08:27:27 -070028#include "wifi_status_util.h"
Roshan Pius3c4e8a32016-10-03 14:53:58 -070029
Roshan Pius35d958c2016-10-06 16:47:38 -070030namespace {
Jong Wook Kimda830c92018-07-23 15:29:38 -070031using android::sp;
xshu5899e8e2018-01-09 15:36:03 -080032using android::base::unique_fd;
Roshan Pius35d958c2016-10-06 16:47:38 -070033using android::hardware::hidl_string;
Roshan Piusabcf78f2017-10-06 16:30:38 -070034using android::hardware::hidl_vec;
Roshan Pius2c06a3f2016-12-15 17:51:40 -080035using android::hardware::wifi::V1_0::ChipModeId;
Roshan Pius52947fb2016-11-18 11:38:07 -080036using android::hardware::wifi::V1_0::IfaceType;
Roshan Pius675609b2017-10-31 14:24:58 -070037using android::hardware::wifi::V1_0::IWifiChip;
Roshan Pius52947fb2016-11-18 11:38:07 -080038
xshu5899e8e2018-01-09 15:36:03 -080039constexpr char kCpioMagic[] = "070701";
40constexpr size_t kMaxBufferSizeBytes = 1024 * 1024;
41constexpr uint32_t kMaxRingBufferFileAgeSeconds = 60 * 60;
xshu37126c92018-04-13 16:24:45 -070042constexpr uint32_t kMaxRingBufferFileNum = 20;
xshu5899e8e2018-01-09 15:36:03 -080043constexpr char kTombstoneFolderPath[] = "/data/vendor/tombstones/wifi/";
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -080044constexpr unsigned kMaxWlanIfaces = 100;
xshu5899e8e2018-01-09 15:36:03 -080045
Roshan Pius35d958c2016-10-06 16:47:38 -070046template <typename Iface>
Roshan Pius675609b2017-10-31 14:24:58 -070047void invalidateAndClear(std::vector<sp<Iface>>& ifaces, sp<Iface> iface) {
48 iface->invalidate();
49 ifaces.erase(std::remove(ifaces.begin(), ifaces.end(), iface),
50 ifaces.end());
51}
52
53template <typename Iface>
54void invalidateAndClearAll(std::vector<sp<Iface>>& ifaces) {
55 for (const auto& iface : ifaces) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070056 iface->invalidate();
Roshan Piusabcf78f2017-10-06 16:30:38 -070057 }
Roshan Pius675609b2017-10-31 14:24:58 -070058 ifaces.clear();
59}
60
61template <typename Iface>
62std::vector<hidl_string> getNames(std::vector<sp<Iface>>& ifaces) {
63 std::vector<hidl_string> names;
64 for (const auto& iface : ifaces) {
65 names.emplace_back(iface->getName());
66 }
67 return names;
68}
69
70template <typename Iface>
71sp<Iface> findUsingName(std::vector<sp<Iface>>& ifaces,
72 const std::string& name) {
73 std::vector<hidl_string> names;
74 for (const auto& iface : ifaces) {
75 if (name == iface->getName()) {
76 return iface;
77 }
78 }
79 return nullptr;
Roshan Pius35d958c2016-10-06 16:47:38 -070080}
Roshan Pius9377a0d2017-10-06 13:18:54 -070081
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -080082std::string getWlanIfaceName(unsigned idx) {
83 if (idx >= kMaxWlanIfaces) {
84 CHECK(false) << "Requested interface beyond wlan" << kMaxWlanIfaces;
85 return {};
86 }
Roshan Pius9377a0d2017-10-06 13:18:54 -070087
Roshan Pius8e3c7ef2017-11-03 09:43:08 -070088 std::array<char, PROPERTY_VALUE_MAX> buffer;
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -080089 std::string propName = "wifi.interface." + std::to_string(idx);
90 auto res = property_get(propName.c_str(), buffer.data(), nullptr);
91 if (res > 0) return buffer.data();
92
93 if (idx == 0 || idx == 1) {
94 const char* altPropName =
95 (idx == 0) ? "wifi.interface" : "wifi.concurrent.interface";
96 res = property_get(altPropName, buffer.data(), nullptr);
97 if (res > 0) return buffer.data();
98 }
99
100 return "wlan" + std::to_string(idx);
Roshan Pius9377a0d2017-10-06 13:18:54 -0700101}
Roshan Pius9377a0d2017-10-06 13:18:54 -0700102
103std::string getP2pIfaceName() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700104 std::array<char, PROPERTY_VALUE_MAX> buffer;
105 property_get("wifi.direct.interface", buffer.data(), "p2p0");
106 return buffer.data();
Roshan Pius9377a0d2017-10-06 13:18:54 -0700107}
108
xshu37126c92018-04-13 16:24:45 -0700109// delete files that meet either conditions:
110// 1. older than a predefined time in the wifi tombstone dir.
111// 2. Files in excess to a predefined amount, starting from the oldest ones
xshu5899e8e2018-01-09 15:36:03 -0800112bool removeOldFilesInternal() {
113 time_t now = time(0);
114 const time_t delete_files_before = now - kMaxRingBufferFileAgeSeconds;
Josh Gaoa568e532018-06-04 18:16:00 -0700115 std::unique_ptr<DIR, decltype(&closedir)> dir_dump(
116 opendir(kTombstoneFolderPath), closedir);
xshu5899e8e2018-01-09 15:36:03 -0800117 if (!dir_dump) {
118 LOG(ERROR) << "Failed to open directory: " << strerror(errno);
119 return false;
120 }
xshu5899e8e2018-01-09 15:36:03 -0800121 struct dirent* dp;
122 bool success = true;
xshu37126c92018-04-13 16:24:45 -0700123 std::list<std::pair<const time_t, std::string>> valid_files;
Josh Gaoa568e532018-06-04 18:16:00 -0700124 while ((dp = readdir(dir_dump.get()))) {
xshu5899e8e2018-01-09 15:36:03 -0800125 if (dp->d_type != DT_REG) {
126 continue;
127 }
128 std::string cur_file_name(dp->d_name);
129 struct stat cur_file_stat;
130 std::string cur_file_path = kTombstoneFolderPath + cur_file_name;
xshu4cb33162018-01-24 15:40:06 -0800131 if (stat(cur_file_path.c_str(), &cur_file_stat) == -1) {
xshu5899e8e2018-01-09 15:36:03 -0800132 LOG(ERROR) << "Failed to get file stat for " << cur_file_path
133 << ": " << strerror(errno);
134 success = false;
xshu4cb33162018-01-24 15:40:06 -0800135 continue;
136 }
xshu37126c92018-04-13 16:24:45 -0700137 const time_t cur_file_time = cur_file_stat.st_mtime;
138 valid_files.push_back(
139 std::pair<const time_t, std::string>(cur_file_time, cur_file_path));
140 }
141 valid_files.sort(); // sort the list of files by last modified time from
142 // small to big.
143 uint32_t cur_file_count = valid_files.size();
144 for (auto cur_file : valid_files) {
145 if (cur_file_count > kMaxRingBufferFileNum ||
146 cur_file.first < delete_files_before) {
147 if (unlink(cur_file.second.c_str()) != 0) {
148 LOG(ERROR) << "Error deleting file " << strerror(errno);
149 success = false;
150 }
151 cur_file_count--;
152 } else {
153 break;
xshu5899e8e2018-01-09 15:36:03 -0800154 }
155 }
156 return success;
157}
158
xshu4cb33162018-01-24 15:40:06 -0800159// Helper function for |cpioArchiveFilesInDir|
160bool cpioWriteHeader(int out_fd, struct stat& st, const char* file_name,
161 size_t file_name_len) {
162 std::array<char, 32 * 1024> read_buf;
163 ssize_t llen =
164 sprintf(read_buf.data(),
165 "%s%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X",
166 kCpioMagic, static_cast<int>(st.st_ino), st.st_mode, st.st_uid,
167 st.st_gid, static_cast<int>(st.st_nlink),
168 static_cast<int>(st.st_mtime), static_cast<int>(st.st_size),
169 major(st.st_dev), minor(st.st_dev), major(st.st_rdev),
170 minor(st.st_rdev), static_cast<uint32_t>(file_name_len), 0);
171 if (write(out_fd, read_buf.data(), llen) == -1) {
172 LOG(ERROR) << "Error writing cpio header to file " << file_name << " "
173 << strerror(errno);
174 return false;
175 }
176 if (write(out_fd, file_name, file_name_len) == -1) {
177 LOG(ERROR) << "Error writing filename to file " << file_name << " "
178 << strerror(errno);
179 return false;
180 }
181
182 // NUL Pad header up to 4 multiple bytes.
183 llen = (llen + file_name_len) % 4;
184 if (llen != 0) {
185 const uint32_t zero = 0;
186 if (write(out_fd, &zero, 4 - llen) == -1) {
187 LOG(ERROR) << "Error padding 0s to file " << file_name << " "
188 << strerror(errno);
189 return false;
190 }
191 }
192 return true;
193}
194
195// Helper function for |cpioArchiveFilesInDir|
196size_t cpioWriteFileContent(int fd_read, int out_fd, struct stat& st) {
197 // writing content of file
198 std::array<char, 32 * 1024> read_buf;
199 ssize_t llen = st.st_size;
200 size_t n_error = 0;
201 while (llen > 0) {
202 ssize_t bytes_read = read(fd_read, read_buf.data(), read_buf.size());
203 if (bytes_read == -1) {
204 LOG(ERROR) << "Error reading file " << strerror(errno);
205 return ++n_error;
206 }
207 llen -= bytes_read;
208 if (write(out_fd, read_buf.data(), bytes_read) == -1) {
209 LOG(ERROR) << "Error writing data to file " << strerror(errno);
210 return ++n_error;
211 }
212 if (bytes_read == 0) { // this should never happen, but just in case
213 // to unstuck from while loop
214 LOG(ERROR) << "Unexpected read result for " << strerror(errno);
215 n_error++;
216 break;
217 }
218 }
219 llen = st.st_size % 4;
220 if (llen != 0) {
221 const uint32_t zero = 0;
222 if (write(out_fd, &zero, 4 - llen) == -1) {
223 LOG(ERROR) << "Error padding 0s to file " << strerror(errno);
224 return ++n_error;
225 }
226 }
227 return n_error;
228}
229
230// Helper function for |cpioArchiveFilesInDir|
231bool cpioWriteFileTrailer(int out_fd) {
232 std::array<char, 4096> read_buf;
233 read_buf.fill(0);
234 if (write(out_fd, read_buf.data(),
235 sprintf(read_buf.data(), "070701%040X%056X%08XTRAILER!!!", 1,
236 0x0b, 0) +
237 4) == -1) {
238 LOG(ERROR) << "Error writing trailing bytes " << strerror(errno);
239 return false;
240 }
241 return true;
242}
243
xshu5899e8e2018-01-09 15:36:03 -0800244// Archives all files in |input_dir| and writes result into |out_fd|
245// Logic obtained from //external/toybox/toys/posix/cpio.c "Output cpio archive"
246// portion
xshu4cb33162018-01-24 15:40:06 -0800247size_t cpioArchiveFilesInDir(int out_fd, const char* input_dir) {
xshu5899e8e2018-01-09 15:36:03 -0800248 struct dirent* dp;
249 size_t n_error = 0;
Josh Gaoa568e532018-06-04 18:16:00 -0700250 std::unique_ptr<DIR, decltype(&closedir)> dir_dump(opendir(input_dir),
251 closedir);
xshu5899e8e2018-01-09 15:36:03 -0800252 if (!dir_dump) {
253 LOG(ERROR) << "Failed to open directory: " << strerror(errno);
xshu4cb33162018-01-24 15:40:06 -0800254 return ++n_error;
xshu5899e8e2018-01-09 15:36:03 -0800255 }
Josh Gaoa568e532018-06-04 18:16:00 -0700256 while ((dp = readdir(dir_dump.get()))) {
xshu5899e8e2018-01-09 15:36:03 -0800257 if (dp->d_type != DT_REG) {
258 continue;
259 }
260 std::string cur_file_name(dp->d_name);
xshu4cb33162018-01-24 15:40:06 -0800261 // string.size() does not include the null terminator. The cpio FreeBSD
262 // file header expects the null character to be included in the length.
263 const size_t file_name_len = cur_file_name.size() + 1;
xshu5899e8e2018-01-09 15:36:03 -0800264 struct stat st;
xshu5899e8e2018-01-09 15:36:03 -0800265 const std::string cur_file_path = kTombstoneFolderPath + cur_file_name;
xshu4cb33162018-01-24 15:40:06 -0800266 if (stat(cur_file_path.c_str(), &st) == -1) {
xshu5899e8e2018-01-09 15:36:03 -0800267 LOG(ERROR) << "Failed to get file stat for " << cur_file_path
268 << ": " << strerror(errno);
269 n_error++;
xshu4cb33162018-01-24 15:40:06 -0800270 continue;
271 }
272 const int fd_read = open(cur_file_path.c_str(), O_RDONLY);
273 if (fd_read == -1) {
274 LOG(ERROR) << "Failed to open file " << cur_file_path << " "
275 << strerror(errno);
276 n_error++;
277 continue;
278 }
279 unique_fd file_auto_closer(fd_read);
280 if (!cpioWriteHeader(out_fd, st, cur_file_name.c_str(),
281 file_name_len)) {
282 return ++n_error;
283 }
284 size_t write_error = cpioWriteFileContent(fd_read, out_fd, st);
285 if (write_error) {
286 return n_error + write_error;
xshu5899e8e2018-01-09 15:36:03 -0800287 }
288 }
xshu4cb33162018-01-24 15:40:06 -0800289 if (!cpioWriteFileTrailer(out_fd)) {
290 return ++n_error;
xshu5899e8e2018-01-09 15:36:03 -0800291 }
292 return n_error;
293}
294
295// Helper function to create a non-const char*.
296std::vector<char> makeCharVec(const std::string& str) {
297 std::vector<char> vec(str.size() + 1);
298 vec.assign(str.begin(), str.end());
299 vec.push_back('\0');
300 return vec;
301}
302
Roshan Piusabcf78f2017-10-06 16:30:38 -0700303} // namespace
Roshan Pius35d958c2016-10-06 16:47:38 -0700304
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700305namespace android {
306namespace hardware {
307namespace wifi {
Jong Wook Kimda830c92018-07-23 15:29:38 -0700308namespace V1_3 {
Roshan Pius79a99752016-10-04 13:03:58 -0700309namespace implementation {
Roshan Pius3c868522016-10-27 12:43:49 -0700310using hidl_return_util::validateAndCall;
Roshan Piusba38d9c2017-12-08 07:32:08 -0800311using hidl_return_util::validateAndCallWithLock;
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700312
Roshan Pius52947fb2016-11-18 11:38:07 -0800313WifiChip::WifiChip(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700314 ChipId chip_id, const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
Roshan Pius200a17d2017-11-01 13:03:35 -0700315 const std::weak_ptr<mode_controller::WifiModeController> mode_controller,
316 const std::weak_ptr<feature_flags::WifiFeatureFlags> feature_flags)
Roshan Pius52947fb2016-11-18 11:38:07 -0800317 : chip_id_(chip_id),
318 legacy_hal_(legacy_hal),
319 mode_controller_(mode_controller),
Roshan Pius200a17d2017-11-01 13:03:35 -0700320 feature_flags_(feature_flags),
Roshan Pius52947fb2016-11-18 11:38:07 -0800321 is_valid_(true),
Tomasz Wasilczykb424da72018-11-15 11:52:57 -0800322 current_mode_id_(feature_flags::chip_mode_ids::kInvalid),
323 modes_(feature_flags.lock()->getChipModes()),
324 debug_ring_buffer_cb_registered_(false) {}
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700325
Roshan Piusaabe5752016-09-29 09:03:59 -0700326void WifiChip::invalidate() {
xshu37126c92018-04-13 16:24:45 -0700327 if (!writeRingbufferFilesInternal()) {
328 LOG(ERROR) << "Error writing files to flash";
329 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700330 invalidateAndRemoveAllIfaces();
331 legacy_hal_.reset();
332 event_cb_handler_.invalidate();
333 is_valid_ = false;
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700334}
335
Roshan Piusabcf78f2017-10-06 16:30:38 -0700336bool WifiChip::isValid() { return is_valid_; }
Roshan Pius3c868522016-10-27 12:43:49 -0700337
Jong Wook Kimda830c92018-07-23 15:29:38 -0700338std::set<sp<V1_2::IWifiChipEventCallback>> WifiChip::getEventCallbacks() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700339 return event_cb_handler_.getCallbacks();
Roshan Pius203cb032016-12-14 17:41:20 -0800340}
341
Roshan Pius5c055462016-10-11 08:27:27 -0700342Return<void> WifiChip::getId(getId_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700343 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
344 &WifiChip::getIdInternal, hidl_status_cb);
Roshan Piuscd566bd2016-10-10 08:03:42 -0700345}
346
Jong Wook Kimda830c92018-07-23 15:29:38 -0700347// Deprecated support for this callback
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700348Return<void> WifiChip::registerEventCallback(
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800349 const sp<V1_0::IWifiChipEventCallback>& event_callback,
Roshan Pius5c055462016-10-11 08:27:27 -0700350 registerEventCallback_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700351 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
352 &WifiChip::registerEventCallbackInternal,
353 hidl_status_cb, event_callback);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700354}
355
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700356Return<void> WifiChip::getCapabilities(getCapabilities_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700357 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
358 &WifiChip::getCapabilitiesInternal, hidl_status_cb);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700359}
360
Roshan Pius5c055462016-10-11 08:27:27 -0700361Return<void> WifiChip::getAvailableModes(getAvailableModes_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700362 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
363 &WifiChip::getAvailableModesInternal,
364 hidl_status_cb);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700365}
366
Roshan Pius2c06a3f2016-12-15 17:51:40 -0800367Return<void> WifiChip::configureChip(ChipModeId mode_id,
Roshan Pius5c055462016-10-11 08:27:27 -0700368 configureChip_cb hidl_status_cb) {
Roshan Piusba38d9c2017-12-08 07:32:08 -0800369 return validateAndCallWithLock(
370 this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
371 &WifiChip::configureChipInternal, hidl_status_cb, mode_id);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700372}
373
Roshan Pius5c055462016-10-11 08:27:27 -0700374Return<void> WifiChip::getMode(getMode_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700375 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
376 &WifiChip::getModeInternal, hidl_status_cb);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700377}
378
Roshan Pius5c055462016-10-11 08:27:27 -0700379Return<void> WifiChip::requestChipDebugInfo(
380 requestChipDebugInfo_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700381 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
382 &WifiChip::requestChipDebugInfoInternal,
383 hidl_status_cb);
Roshan Pius5c055462016-10-11 08:27:27 -0700384}
385
386Return<void> WifiChip::requestDriverDebugDump(
387 requestDriverDebugDump_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700388 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
389 &WifiChip::requestDriverDebugDumpInternal,
390 hidl_status_cb);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700391}
392
Roshan Pius5c055462016-10-11 08:27:27 -0700393Return<void> WifiChip::requestFirmwareDebugDump(
394 requestFirmwareDebugDump_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700395 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
396 &WifiChip::requestFirmwareDebugDumpInternal,
397 hidl_status_cb);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700398}
399
Roshan Pius5c055462016-10-11 08:27:27 -0700400Return<void> WifiChip::createApIface(createApIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700401 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
402 &WifiChip::createApIfaceInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700403}
404
Roshan Pius5c055462016-10-11 08:27:27 -0700405Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700406 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
407 &WifiChip::getApIfaceNamesInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700408}
409
Roshan Pius5c055462016-10-11 08:27:27 -0700410Return<void> WifiChip::getApIface(const hidl_string& ifname,
411 getApIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700412 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
413 &WifiChip::getApIfaceInternal, hidl_status_cb,
414 ifname);
Roshan Pius35d958c2016-10-06 16:47:38 -0700415}
416
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800417Return<void> WifiChip::removeApIface(const hidl_string& ifname,
418 removeApIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700419 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
420 &WifiChip::removeApIfaceInternal, hidl_status_cb,
421 ifname);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800422}
423
Roshan Pius5c055462016-10-11 08:27:27 -0700424Return<void> WifiChip::createNanIface(createNanIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700425 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
426 &WifiChip::createNanIfaceInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700427}
428
Roshan Pius5c055462016-10-11 08:27:27 -0700429Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700430 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
431 &WifiChip::getNanIfaceNamesInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700432}
433
434Return<void> WifiChip::getNanIface(const hidl_string& ifname,
Roshan Pius5c055462016-10-11 08:27:27 -0700435 getNanIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700436 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
437 &WifiChip::getNanIfaceInternal, hidl_status_cb,
438 ifname);
Roshan Pius35d958c2016-10-06 16:47:38 -0700439}
440
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800441Return<void> WifiChip::removeNanIface(const hidl_string& ifname,
442 removeNanIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700443 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
444 &WifiChip::removeNanIfaceInternal, hidl_status_cb,
445 ifname);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800446}
447
Roshan Pius5c055462016-10-11 08:27:27 -0700448Return<void> WifiChip::createP2pIface(createP2pIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700449 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
450 &WifiChip::createP2pIfaceInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700451}
452
Roshan Pius5c055462016-10-11 08:27:27 -0700453Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700454 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
455 &WifiChip::getP2pIfaceNamesInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700456}
457
458Return<void> WifiChip::getP2pIface(const hidl_string& ifname,
Roshan Pius5c055462016-10-11 08:27:27 -0700459 getP2pIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700460 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
461 &WifiChip::getP2pIfaceInternal, hidl_status_cb,
462 ifname);
Roshan Pius35d958c2016-10-06 16:47:38 -0700463}
464
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800465Return<void> WifiChip::removeP2pIface(const hidl_string& ifname,
466 removeP2pIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700467 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
468 &WifiChip::removeP2pIfaceInternal, hidl_status_cb,
469 ifname);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800470}
471
Roshan Pius5c055462016-10-11 08:27:27 -0700472Return<void> WifiChip::createStaIface(createStaIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700473 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
474 &WifiChip::createStaIfaceInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700475}
476
Roshan Pius5c055462016-10-11 08:27:27 -0700477Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700478 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
479 &WifiChip::getStaIfaceNamesInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700480}
481
482Return<void> WifiChip::getStaIface(const hidl_string& ifname,
Roshan Pius5c055462016-10-11 08:27:27 -0700483 getStaIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700484 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
485 &WifiChip::getStaIfaceInternal, hidl_status_cb,
486 ifname);
Roshan Pius35d958c2016-10-06 16:47:38 -0700487}
488
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800489Return<void> WifiChip::removeStaIface(const hidl_string& ifname,
490 removeStaIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700491 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
492 &WifiChip::removeStaIfaceInternal, hidl_status_cb,
493 ifname);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800494}
495
Roshan Pius5c055462016-10-11 08:27:27 -0700496Return<void> WifiChip::createRttController(
497 const sp<IWifiIface>& bound_iface, createRttController_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700498 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
499 &WifiChip::createRttControllerInternal,
500 hidl_status_cb, bound_iface);
Roshan Pius59268282016-10-06 20:23:47 -0700501}
502
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700503Return<void> WifiChip::getDebugRingBuffersStatus(
504 getDebugRingBuffersStatus_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700505 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
506 &WifiChip::getDebugRingBuffersStatusInternal,
507 hidl_status_cb);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700508}
509
510Return<void> WifiChip::startLoggingToDebugRingBuffer(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700511 const hidl_string& ring_name, WifiDebugRingBufferVerboseLevel verbose_level,
512 uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes,
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700513 startLoggingToDebugRingBuffer_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700514 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
515 &WifiChip::startLoggingToDebugRingBufferInternal,
516 hidl_status_cb, ring_name, verbose_level,
517 max_interval_in_sec, min_data_size_in_bytes);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700518}
519
520Return<void> WifiChip::forceDumpToDebugRingBuffer(
521 const hidl_string& ring_name,
522 forceDumpToDebugRingBuffer_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700523 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
524 &WifiChip::forceDumpToDebugRingBufferInternal,
525 hidl_status_cb, ring_name);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700526}
527
Roshan Pius8c0c8e92017-02-24 08:07:42 -0800528Return<void> WifiChip::stopLoggingToDebugRingBuffer(
529 stopLoggingToDebugRingBuffer_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700530 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
531 &WifiChip::stopLoggingToDebugRingBufferInternal,
532 hidl_status_cb);
Roshan Pius8c0c8e92017-02-24 08:07:42 -0800533}
534
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700535Return<void> WifiChip::getDebugHostWakeReasonStats(
536 getDebugHostWakeReasonStats_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700537 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
538 &WifiChip::getDebugHostWakeReasonStatsInternal,
539 hidl_status_cb);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700540}
541
Roshan Pius203cb032016-12-14 17:41:20 -0800542Return<void> WifiChip::enableDebugErrorAlerts(
543 bool enable, enableDebugErrorAlerts_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700544 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
545 &WifiChip::enableDebugErrorAlertsInternal,
546 hidl_status_cb, enable);
Roshan Pius203cb032016-12-14 17:41:20 -0800547}
548
Roshan Pius735ff432017-07-25 08:48:08 -0700549Return<void> WifiChip::selectTxPowerScenario(
Jong Wook Kimda830c92018-07-23 15:29:38 -0700550 V1_1::IWifiChip::TxPowerScenario scenario,
551 selectTxPowerScenario_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700552 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
553 &WifiChip::selectTxPowerScenarioInternal,
554 hidl_status_cb, scenario);
Roshan Piusdbd83ef2017-06-20 12:05:40 -0700555}
556
Roshan Pius735ff432017-07-25 08:48:08 -0700557Return<void> WifiChip::resetTxPowerScenario(
558 resetTxPowerScenario_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700559 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
560 &WifiChip::resetTxPowerScenarioInternal,
561 hidl_status_cb);
Roshan Piusdbd83ef2017-06-20 12:05:40 -0700562}
563
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700564Return<void> WifiChip::setLatencyMode(LatencyMode mode,
565 setLatencyMode_cb hidl_status_cb) {
566 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
567 &WifiChip::setLatencyModeInternal, hidl_status_cb,
568 mode);
569}
570
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800571Return<void> WifiChip::registerEventCallback_1_2(
Jong Wook Kimda830c92018-07-23 15:29:38 -0700572 const sp<V1_2::IWifiChipEventCallback>& event_callback,
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800573 registerEventCallback_cb hidl_status_cb) {
574 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
575 &WifiChip::registerEventCallbackInternal_1_2,
576 hidl_status_cb, event_callback);
577}
578
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800579Return<void> WifiChip::selectTxPowerScenario_1_2(
Jong Wook Kimda830c92018-07-23 15:29:38 -0700580 TxPowerScenario scenario, selectTxPowerScenario_cb hidl_status_cb) {
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800581 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
Jong Wook Kimda830c92018-07-23 15:29:38 -0700582 &WifiChip::selectTxPowerScenarioInternal_1_2,
583 hidl_status_cb, scenario);
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800584}
585
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700586Return<void> WifiChip::getCapabilities_1_3(getCapabilities_cb hidl_status_cb) {
587 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
588 &WifiChip::getCapabilitiesInternal_1_3,
589 hidl_status_cb);
590}
591
xshu5899e8e2018-01-09 15:36:03 -0800592Return<void> WifiChip::debug(const hidl_handle& handle,
593 const hidl_vec<hidl_string>&) {
594 if (handle != nullptr && handle->numFds >= 1) {
595 int fd = handle->data[0];
596 if (!writeRingbufferFilesInternal()) {
597 LOG(ERROR) << "Error writing files to flash";
598 }
xshu4cb33162018-01-24 15:40:06 -0800599 uint32_t n_error = cpioArchiveFilesInDir(fd, kTombstoneFolderPath);
xshu5899e8e2018-01-09 15:36:03 -0800600 if (n_error != 0) {
601 LOG(ERROR) << n_error << " errors occured in cpio function";
602 }
603 fsync(fd);
604 } else {
605 LOG(ERROR) << "File handle error";
606 }
607 return Void();
608}
609
Roshan Pius35d958c2016-10-06 16:47:38 -0700610void WifiChip::invalidateAndRemoveAllIfaces() {
Roshan Pius675609b2017-10-31 14:24:58 -0700611 invalidateAndClearAll(ap_ifaces_);
612 invalidateAndClearAll(nan_ifaces_);
613 invalidateAndClearAll(p2p_ifaces_);
614 invalidateAndClearAll(sta_ifaces_);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700615 // Since all the ifaces are invalid now, all RTT controller objects
616 // using those ifaces also need to be invalidated.
617 for (const auto& rtt : rtt_controllers_) {
618 rtt->invalidate();
619 }
620 rtt_controllers_.clear();
Roshan Pius35d958c2016-10-06 16:47:38 -0700621}
622
Roshan Pius3c868522016-10-27 12:43:49 -0700623std::pair<WifiStatus, ChipId> WifiChip::getIdInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700624 return {createWifiStatus(WifiStatusCode::SUCCESS), chip_id_};
Roshan Pius3c868522016-10-27 12:43:49 -0700625}
626
627WifiStatus WifiChip::registerEventCallbackInternal(
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800628 const sp<V1_0::IWifiChipEventCallback>& /* event_callback */) {
629 // Deprecated support for this callback.
630 return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
Roshan Pius3c868522016-10-27 12:43:49 -0700631}
632
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700633std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal() {
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700634 // Deprecated support for this callback.
635 return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), 0};
636}
637
638std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal_1_3() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700639 legacy_hal::wifi_error legacy_status;
640 uint32_t legacy_feature_set;
641 uint32_t legacy_logger_feature_set;
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800642 const auto ifname = getWlanIfaceName(0);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700643 std::tie(legacy_status, legacy_feature_set) =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800644 legacy_hal_.lock()->getSupportedFeatureSet(ifname);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700645 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
646 return {createWifiStatusFromLegacyError(legacy_status), 0};
647 }
648 std::tie(legacy_status, legacy_logger_feature_set) =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800649 legacy_hal_.lock()->getLoggerSupportedFeatureSet(ifname);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700650 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
Roshan Pius876220f2017-12-28 16:19:06 -0800651 // some devices don't support querying logger feature set
652 legacy_logger_feature_set = 0;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700653 }
654 uint32_t hidl_caps;
655 if (!hidl_struct_util::convertLegacyFeaturesToHidlChipCapabilities(
656 legacy_feature_set, legacy_logger_feature_set, &hidl_caps)) {
657 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), 0};
658 }
659 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700660}
661
Roshan Pius3c868522016-10-27 12:43:49 -0700662std::pair<WifiStatus, std::vector<IWifiChip::ChipMode>>
663WifiChip::getAvailableModesInternal() {
Roshan Piuscc338202017-11-02 13:54:09 -0700664 return {createWifiStatus(WifiStatusCode::SUCCESS), modes_};
Roshan Pius3c868522016-10-27 12:43:49 -0700665}
666
Roshan Piusba38d9c2017-12-08 07:32:08 -0800667WifiStatus WifiChip::configureChipInternal(
668 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock,
669 ChipModeId mode_id) {
Roshan Piuscc338202017-11-02 13:54:09 -0700670 if (!isValidModeId(mode_id)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700671 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
672 }
673 if (mode_id == current_mode_id_) {
674 LOG(DEBUG) << "Already in the specified mode " << mode_id;
675 return createWifiStatus(WifiStatusCode::SUCCESS);
676 }
Roshan Piusba38d9c2017-12-08 07:32:08 -0800677 WifiStatus status = handleChipConfiguration(lock, mode_id);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700678 if (status.code != WifiStatusCode::SUCCESS) {
679 for (const auto& callback : event_cb_handler_.getCallbacks()) {
680 if (!callback->onChipReconfigureFailure(status).isOk()) {
681 LOG(ERROR)
682 << "Failed to invoke onChipReconfigureFailure callback";
683 }
684 }
685 return status;
686 }
Roshan Piusd37341f2017-01-31 13:13:28 -0800687 for (const auto& callback : event_cb_handler_.getCallbacks()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700688 if (!callback->onChipReconfigured(mode_id).isOk()) {
689 LOG(ERROR) << "Failed to invoke onChipReconfigured callback";
690 }
Roshan Pius52947fb2016-11-18 11:38:07 -0800691 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700692 current_mode_id_ = mode_id;
Roshan Piusba38d9c2017-12-08 07:32:08 -0800693 LOG(INFO) << "Configured chip in mode " << mode_id;
Roshan Pius2c06a3f2016-12-15 17:51:40 -0800694 return status;
Roshan Pius3c868522016-10-27 12:43:49 -0700695}
696
697std::pair<WifiStatus, uint32_t> WifiChip::getModeInternal() {
Roshan Piuscc338202017-11-02 13:54:09 -0700698 if (!isValidModeId(current_mode_id_)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700699 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE),
700 current_mode_id_};
701 }
702 return {createWifiStatus(WifiStatusCode::SUCCESS), current_mode_id_};
Roshan Pius3c868522016-10-27 12:43:49 -0700703}
704
705std::pair<WifiStatus, IWifiChip::ChipDebugInfo>
706WifiChip::requestChipDebugInfoInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700707 IWifiChip::ChipDebugInfo result;
708 legacy_hal::wifi_error legacy_status;
709 std::string driver_desc;
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800710 const auto ifname = getWlanIfaceName(0);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700711 std::tie(legacy_status, driver_desc) =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800712 legacy_hal_.lock()->getDriverVersion(ifname);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700713 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
714 LOG(ERROR) << "Failed to get driver version: "
715 << legacyErrorToString(legacy_status);
716 WifiStatus status = createWifiStatusFromLegacyError(
717 legacy_status, "failed to get driver version");
718 return {status, result};
719 }
720 result.driverDescription = driver_desc.c_str();
Roshan Pius3c868522016-10-27 12:43:49 -0700721
Roshan Piusabcf78f2017-10-06 16:30:38 -0700722 std::string firmware_desc;
723 std::tie(legacy_status, firmware_desc) =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800724 legacy_hal_.lock()->getFirmwareVersion(ifname);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700725 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
726 LOG(ERROR) << "Failed to get firmware version: "
727 << legacyErrorToString(legacy_status);
728 WifiStatus status = createWifiStatusFromLegacyError(
729 legacy_status, "failed to get firmware version");
730 return {status, result};
731 }
732 result.firmwareDescription = firmware_desc.c_str();
Roshan Pius3c868522016-10-27 12:43:49 -0700733
Roshan Piusabcf78f2017-10-06 16:30:38 -0700734 return {createWifiStatus(WifiStatusCode::SUCCESS), result};
Roshan Pius3c868522016-10-27 12:43:49 -0700735}
736
737std::pair<WifiStatus, std::vector<uint8_t>>
738WifiChip::requestDriverDebugDumpInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700739 legacy_hal::wifi_error legacy_status;
740 std::vector<uint8_t> driver_dump;
741 std::tie(legacy_status, driver_dump) =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800742 legacy_hal_.lock()->requestDriverMemoryDump(getWlanIfaceName(0));
Roshan Piusabcf78f2017-10-06 16:30:38 -0700743 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
744 LOG(ERROR) << "Failed to get driver debug dump: "
745 << legacyErrorToString(legacy_status);
746 return {createWifiStatusFromLegacyError(legacy_status),
747 std::vector<uint8_t>()};
748 }
749 return {createWifiStatus(WifiStatusCode::SUCCESS), driver_dump};
Roshan Pius3c868522016-10-27 12:43:49 -0700750}
751
752std::pair<WifiStatus, std::vector<uint8_t>>
753WifiChip::requestFirmwareDebugDumpInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700754 legacy_hal::wifi_error legacy_status;
755 std::vector<uint8_t> firmware_dump;
756 std::tie(legacy_status, firmware_dump) =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800757 legacy_hal_.lock()->requestFirmwareMemoryDump(getWlanIfaceName(0));
Roshan Piusabcf78f2017-10-06 16:30:38 -0700758 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
759 LOG(ERROR) << "Failed to get firmware debug dump: "
760 << legacyErrorToString(legacy_status);
761 return {createWifiStatusFromLegacyError(legacy_status), {}};
762 }
763 return {createWifiStatus(WifiStatusCode::SUCCESS), firmware_dump};
Roshan Pius3c868522016-10-27 12:43:49 -0700764}
765
766std::pair<WifiStatus, sp<IWifiApIface>> WifiChip::createApIfaceInternal() {
Roshan Piuscc338202017-11-02 13:54:09 -0700767 if (!canCurrentModeSupportIfaceOfType(IfaceType::AP)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700768 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
Roshan Piusbc662202017-01-30 17:07:42 -0800769 }
Roshan Pius8e3c7ef2017-11-03 09:43:08 -0700770 std::string ifname = allocateApOrStaIfaceName();
Roshan Pius675609b2017-10-31 14:24:58 -0700771 sp<WifiApIface> iface = new WifiApIface(ifname, legacy_hal_);
772 ap_ifaces_.push_back(iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700773 for (const auto& callback : event_cb_handler_.getCallbacks()) {
774 if (!callback->onIfaceAdded(IfaceType::AP, ifname).isOk()) {
775 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
776 }
777 }
Roshan Pius675609b2017-10-31 14:24:58 -0700778 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -0700779}
780
781std::pair<WifiStatus, std::vector<hidl_string>>
782WifiChip::getApIfaceNamesInternal() {
Roshan Pius675609b2017-10-31 14:24:58 -0700783 if (ap_ifaces_.empty()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700784 return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
785 }
Roshan Pius675609b2017-10-31 14:24:58 -0700786 return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(ap_ifaces_)};
Roshan Pius3c868522016-10-27 12:43:49 -0700787}
788
789std::pair<WifiStatus, sp<IWifiApIface>> WifiChip::getApIfaceInternal(
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800790 const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -0700791 const auto iface = findUsingName(ap_ifaces_, ifname);
792 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700793 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
794 }
Roshan Pius675609b2017-10-31 14:24:58 -0700795 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -0700796}
797
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800798WifiStatus WifiChip::removeApIfaceInternal(const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -0700799 const auto iface = findUsingName(ap_ifaces_, ifname);
800 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700801 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
Roshan Piusbc662202017-01-30 17:07:42 -0800802 }
Roshan Pius675609b2017-10-31 14:24:58 -0700803 invalidateAndClear(ap_ifaces_, iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700804 for (const auto& callback : event_cb_handler_.getCallbacks()) {
805 if (!callback->onIfaceRemoved(IfaceType::AP, ifname).isOk()) {
806 LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
807 }
808 }
809 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800810}
811
Roshan Pius3c868522016-10-27 12:43:49 -0700812std::pair<WifiStatus, sp<IWifiNanIface>> WifiChip::createNanIfaceInternal() {
Roshan Piuscc338202017-11-02 13:54:09 -0700813 if (!canCurrentModeSupportIfaceOfType(IfaceType::NAN)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700814 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
Etan Cohenc5700402017-03-08 16:43:38 -0800815 }
Roshan Pius8e3c7ef2017-11-03 09:43:08 -0700816 // These are still assumed to be based on wlan0.
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800817 std::string ifname = getWlanIfaceName(0);
Roshan Piuscc338202017-11-02 13:54:09 -0700818 sp<WifiNanIface> iface = new WifiNanIface(ifname, legacy_hal_);
819 nan_ifaces_.push_back(iface);
820 for (const auto& callback : event_cb_handler_.getCallbacks()) {
821 if (!callback->onIfaceAdded(IfaceType::NAN, ifname).isOk()) {
822 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
823 }
824 }
825 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -0700826}
827
828std::pair<WifiStatus, std::vector<hidl_string>>
829WifiChip::getNanIfaceNamesInternal() {
Roshan Pius675609b2017-10-31 14:24:58 -0700830 if (nan_ifaces_.empty()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700831 return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
832 }
Roshan Pius675609b2017-10-31 14:24:58 -0700833 return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(nan_ifaces_)};
Roshan Pius3c868522016-10-27 12:43:49 -0700834}
835
836std::pair<WifiStatus, sp<IWifiNanIface>> WifiChip::getNanIfaceInternal(
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800837 const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -0700838 const auto iface = findUsingName(nan_ifaces_, ifname);
839 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700840 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
841 }
Roshan Pius675609b2017-10-31 14:24:58 -0700842 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -0700843}
844
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800845WifiStatus WifiChip::removeNanIfaceInternal(const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -0700846 const auto iface = findUsingName(nan_ifaces_, ifname);
847 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700848 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
Roshan Piusbc662202017-01-30 17:07:42 -0800849 }
Roshan Pius675609b2017-10-31 14:24:58 -0700850 invalidateAndClear(nan_ifaces_, iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700851 for (const auto& callback : event_cb_handler_.getCallbacks()) {
852 if (!callback->onIfaceRemoved(IfaceType::NAN, ifname).isOk()) {
853 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
854 }
855 }
856 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800857}
858
Roshan Pius3c868522016-10-27 12:43:49 -0700859std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::createP2pIfaceInternal() {
Roshan Piuscc338202017-11-02 13:54:09 -0700860 if (!canCurrentModeSupportIfaceOfType(IfaceType::P2P)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700861 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
Roshan Piusbc662202017-01-30 17:07:42 -0800862 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700863 std::string ifname = getP2pIfaceName();
Roshan Pius675609b2017-10-31 14:24:58 -0700864 sp<WifiP2pIface> iface = new WifiP2pIface(ifname, legacy_hal_);
865 p2p_ifaces_.push_back(iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700866 for (const auto& callback : event_cb_handler_.getCallbacks()) {
867 if (!callback->onIfaceAdded(IfaceType::P2P, ifname).isOk()) {
868 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
869 }
870 }
Roshan Pius675609b2017-10-31 14:24:58 -0700871 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -0700872}
873
874std::pair<WifiStatus, std::vector<hidl_string>>
875WifiChip::getP2pIfaceNamesInternal() {
Roshan Pius675609b2017-10-31 14:24:58 -0700876 if (p2p_ifaces_.empty()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700877 return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
878 }
Roshan Pius675609b2017-10-31 14:24:58 -0700879 return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(p2p_ifaces_)};
Roshan Pius3c868522016-10-27 12:43:49 -0700880}
881
882std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::getP2pIfaceInternal(
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800883 const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -0700884 const auto iface = findUsingName(p2p_ifaces_, ifname);
885 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700886 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
887 }
Roshan Pius675609b2017-10-31 14:24:58 -0700888 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -0700889}
890
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800891WifiStatus WifiChip::removeP2pIfaceInternal(const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -0700892 const auto iface = findUsingName(p2p_ifaces_, ifname);
893 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700894 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
Roshan Piusbc662202017-01-30 17:07:42 -0800895 }
Roshan Pius675609b2017-10-31 14:24:58 -0700896 invalidateAndClear(p2p_ifaces_, iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700897 for (const auto& callback : event_cb_handler_.getCallbacks()) {
898 if (!callback->onIfaceRemoved(IfaceType::P2P, ifname).isOk()) {
899 LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
900 }
901 }
902 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800903}
904
Roshan Pius3c868522016-10-27 12:43:49 -0700905std::pair<WifiStatus, sp<IWifiStaIface>> WifiChip::createStaIfaceInternal() {
Roshan Piuscc338202017-11-02 13:54:09 -0700906 if (!canCurrentModeSupportIfaceOfType(IfaceType::STA)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700907 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
Roshan Piusbc662202017-01-30 17:07:42 -0800908 }
Roshan Pius8e3c7ef2017-11-03 09:43:08 -0700909 std::string ifname = allocateApOrStaIfaceName();
Roshan Pius675609b2017-10-31 14:24:58 -0700910 sp<WifiStaIface> iface = new WifiStaIface(ifname, legacy_hal_);
911 sta_ifaces_.push_back(iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700912 for (const auto& callback : event_cb_handler_.getCallbacks()) {
913 if (!callback->onIfaceAdded(IfaceType::STA, ifname).isOk()) {
914 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
915 }
916 }
Roshan Pius675609b2017-10-31 14:24:58 -0700917 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -0700918}
919
920std::pair<WifiStatus, std::vector<hidl_string>>
921WifiChip::getStaIfaceNamesInternal() {
Roshan Pius675609b2017-10-31 14:24:58 -0700922 if (sta_ifaces_.empty()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700923 return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
924 }
Roshan Pius675609b2017-10-31 14:24:58 -0700925 return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(sta_ifaces_)};
Roshan Pius3c868522016-10-27 12:43:49 -0700926}
927
928std::pair<WifiStatus, sp<IWifiStaIface>> WifiChip::getStaIfaceInternal(
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800929 const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -0700930 const auto iface = findUsingName(sta_ifaces_, ifname);
931 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700932 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
933 }
Roshan Pius675609b2017-10-31 14:24:58 -0700934 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -0700935}
936
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800937WifiStatus WifiChip::removeStaIfaceInternal(const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -0700938 const auto iface = findUsingName(sta_ifaces_, ifname);
939 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700940 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
Roshan Piusbc662202017-01-30 17:07:42 -0800941 }
Roshan Pius675609b2017-10-31 14:24:58 -0700942 invalidateAndClear(sta_ifaces_, iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700943 for (const auto& callback : event_cb_handler_.getCallbacks()) {
944 if (!callback->onIfaceRemoved(IfaceType::STA, ifname).isOk()) {
945 LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
946 }
947 }
948 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800949}
950
Roshan Pius3c868522016-10-27 12:43:49 -0700951std::pair<WifiStatus, sp<IWifiRttController>>
952WifiChip::createRttControllerInternal(const sp<IWifiIface>& bound_iface) {
Etan Cohen7240a1a2018-08-29 08:14:09 -0700953 if (sta_ifaces_.size() == 0 &&
954 !canCurrentModeSupportIfaceOfType(IfaceType::STA)) {
955 LOG(ERROR) << "createRttControllerInternal: Chip cannot support STAs "
956 "(and RTT by extension)";
957 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
958 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700959 sp<WifiRttController> rtt =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800960 new WifiRttController(getWlanIfaceName(0), bound_iface, legacy_hal_);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700961 rtt_controllers_.emplace_back(rtt);
962 return {createWifiStatus(WifiStatusCode::SUCCESS), rtt};
Roshan Pius3c868522016-10-27 12:43:49 -0700963}
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700964
965std::pair<WifiStatus, std::vector<WifiDebugRingBufferStatus>>
966WifiChip::getDebugRingBuffersStatusInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700967 legacy_hal::wifi_error legacy_status;
968 std::vector<legacy_hal::wifi_ring_buffer_status>
969 legacy_ring_buffer_status_vec;
970 std::tie(legacy_status, legacy_ring_buffer_status_vec) =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800971 legacy_hal_.lock()->getRingBuffersStatus(getWlanIfaceName(0));
Roshan Piusabcf78f2017-10-06 16:30:38 -0700972 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
973 return {createWifiStatusFromLegacyError(legacy_status), {}};
974 }
975 std::vector<WifiDebugRingBufferStatus> hidl_ring_buffer_status_vec;
976 if (!hidl_struct_util::convertLegacyVectorOfDebugRingBufferStatusToHidl(
977 legacy_ring_buffer_status_vec, &hidl_ring_buffer_status_vec)) {
978 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
979 }
980 return {createWifiStatus(WifiStatusCode::SUCCESS),
981 hidl_ring_buffer_status_vec};
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700982}
983
984WifiStatus WifiChip::startLoggingToDebugRingBufferInternal(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700985 const hidl_string& ring_name, WifiDebugRingBufferVerboseLevel verbose_level,
986 uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes) {
987 WifiStatus status = registerDebugRingBufferCallback();
988 if (status.code != WifiStatusCode::SUCCESS) {
989 return status;
990 }
991 legacy_hal::wifi_error legacy_status =
992 legacy_hal_.lock()->startRingBufferLogging(
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800993 getWlanIfaceName(0), ring_name,
Roshan Piusabcf78f2017-10-06 16:30:38 -0700994 static_cast<
995 std::underlying_type<WifiDebugRingBufferVerboseLevel>::type>(
996 verbose_level),
997 max_interval_in_sec, min_data_size_in_bytes);
xshu5899e8e2018-01-09 15:36:03 -0800998 ringbuffer_map_.insert(std::pair<std::string, Ringbuffer>(
999 ring_name, Ringbuffer(kMaxBufferSizeBytes)));
Roshan Piusabcf78f2017-10-06 16:30:38 -07001000 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001001}
1002
1003WifiStatus WifiChip::forceDumpToDebugRingBufferInternal(
Roshan Piuse2d0ab52016-12-05 15:24:20 -08001004 const hidl_string& ring_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001005 WifiStatus status = registerDebugRingBufferCallback();
1006 if (status.code != WifiStatusCode::SUCCESS) {
1007 return status;
1008 }
1009 legacy_hal::wifi_error legacy_status =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001010 legacy_hal_.lock()->getRingBufferData(getWlanIfaceName(0), ring_name);
xshu5899e8e2018-01-09 15:36:03 -08001011
Roshan Piusabcf78f2017-10-06 16:30:38 -07001012 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001013}
1014
Roshan Pius8c0c8e92017-02-24 08:07:42 -08001015WifiStatus WifiChip::stopLoggingToDebugRingBufferInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001016 legacy_hal::wifi_error legacy_status =
1017 legacy_hal_.lock()->deregisterRingBufferCallbackHandler(
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001018 getWlanIfaceName(0));
Roshan Piusabcf78f2017-10-06 16:30:38 -07001019 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius8c0c8e92017-02-24 08:07:42 -08001020}
1021
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001022std::pair<WifiStatus, WifiDebugHostWakeReasonStats>
1023WifiChip::getDebugHostWakeReasonStatsInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001024 legacy_hal::wifi_error legacy_status;
1025 legacy_hal::WakeReasonStats legacy_stats;
1026 std::tie(legacy_status, legacy_stats) =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001027 legacy_hal_.lock()->getWakeReasonStats(getWlanIfaceName(0));
Roshan Piusabcf78f2017-10-06 16:30:38 -07001028 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1029 return {createWifiStatusFromLegacyError(legacy_status), {}};
1030 }
1031 WifiDebugHostWakeReasonStats hidl_stats;
1032 if (!hidl_struct_util::convertLegacyWakeReasonStatsToHidl(legacy_stats,
1033 &hidl_stats)) {
1034 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
1035 }
1036 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_stats};
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001037}
1038
Roshan Pius203cb032016-12-14 17:41:20 -08001039WifiStatus WifiChip::enableDebugErrorAlertsInternal(bool enable) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001040 legacy_hal::wifi_error legacy_status;
1041 if (enable) {
1042 android::wp<WifiChip> weak_ptr_this(this);
1043 const auto& on_alert_callback = [weak_ptr_this](
1044 int32_t error_code,
1045 std::vector<uint8_t> debug_data) {
1046 const auto shared_ptr_this = weak_ptr_this.promote();
1047 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
1048 LOG(ERROR) << "Callback invoked on an invalid object";
1049 return;
1050 }
1051 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
1052 if (!callback->onDebugErrorAlert(error_code, debug_data)
1053 .isOk()) {
1054 LOG(ERROR) << "Failed to invoke onDebugErrorAlert callback";
1055 }
1056 }
1057 };
1058 legacy_status = legacy_hal_.lock()->registerErrorAlertCallbackHandler(
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001059 getWlanIfaceName(0), on_alert_callback);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001060 } else {
1061 legacy_status = legacy_hal_.lock()->deregisterErrorAlertCallbackHandler(
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001062 getWlanIfaceName(0));
Roshan Piusabcf78f2017-10-06 16:30:38 -07001063 }
1064 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius203cb032016-12-14 17:41:20 -08001065}
Roshan Pius2c06a3f2016-12-15 17:51:40 -08001066
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -08001067WifiStatus WifiChip::selectTxPowerScenarioInternal(
Jong Wook Kimda830c92018-07-23 15:29:38 -07001068 V1_1::IWifiChip::TxPowerScenario scenario) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001069 auto legacy_status = legacy_hal_.lock()->selectTxPowerScenario(
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001070 getWlanIfaceName(0),
Roshan Piusabcf78f2017-10-06 16:30:38 -07001071 hidl_struct_util::convertHidlTxPowerScenarioToLegacy(scenario));
1072 return createWifiStatusFromLegacyError(legacy_status);
Roshan Piusdbd83ef2017-06-20 12:05:40 -07001073}
1074
Roshan Pius735ff432017-07-25 08:48:08 -07001075WifiStatus WifiChip::resetTxPowerScenarioInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001076 auto legacy_status =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001077 legacy_hal_.lock()->resetTxPowerScenario(getWlanIfaceName(0));
Roshan Piusabcf78f2017-10-06 16:30:38 -07001078 return createWifiStatusFromLegacyError(legacy_status);
Roshan Piusdbd83ef2017-06-20 12:05:40 -07001079}
1080
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -07001081WifiStatus WifiChip::setLatencyModeInternal(LatencyMode mode) {
1082 auto legacy_status = legacy_hal_.lock()->setLatencyMode(
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001083 getWlanIfaceName(0),
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -07001084 hidl_struct_util::convertHidlLatencyModeToLegacy(mode));
1085 return createWifiStatusFromLegacyError(legacy_status);
1086}
1087
Roshan Pius1ce92cf2018-01-22 16:12:19 -08001088WifiStatus WifiChip::registerEventCallbackInternal_1_2(
Jong Wook Kimda830c92018-07-23 15:29:38 -07001089 const sp<V1_2::IWifiChipEventCallback>& event_callback) {
Roshan Pius1ce92cf2018-01-22 16:12:19 -08001090 if (!event_cb_handler_.addCallback(event_callback)) {
1091 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
1092 }
1093 return createWifiStatus(WifiStatusCode::SUCCESS);
1094}
1095
Jong Wook Kimda830c92018-07-23 15:29:38 -07001096WifiStatus WifiChip::selectTxPowerScenarioInternal_1_2(
1097 TxPowerScenario scenario) {
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -08001098 auto legacy_status = legacy_hal_.lock()->selectTxPowerScenario(
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001099 getWlanIfaceName(0),
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -08001100 hidl_struct_util::convertHidlTxPowerScenarioToLegacy_1_2(scenario));
1101 return createWifiStatusFromLegacyError(legacy_status);
1102}
1103
Roshan Piusba38d9c2017-12-08 07:32:08 -08001104WifiStatus WifiChip::handleChipConfiguration(
1105 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock,
1106 ChipModeId mode_id) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001107 // If the chip is already configured in a different mode, stop
1108 // the legacy HAL and then start it after firmware mode change.
Roshan Piuscc338202017-11-02 13:54:09 -07001109 if (isValidModeId(current_mode_id_)) {
Roshan Piusba38d9c2017-12-08 07:32:08 -08001110 LOG(INFO) << "Reconfiguring chip from mode " << current_mode_id_
1111 << " to mode " << mode_id;
1112 invalidateAndRemoveAllIfaces();
1113 legacy_hal::wifi_error legacy_status =
1114 legacy_hal_.lock()->stop(lock, []() {});
1115 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1116 LOG(ERROR) << "Failed to stop legacy HAL: "
1117 << legacyErrorToString(legacy_status);
1118 return createWifiStatusFromLegacyError(legacy_status);
1119 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001120 }
Roshan Piuscc338202017-11-02 13:54:09 -07001121 // Firmware mode change not needed for V2 devices.
1122 bool success = true;
Tomasz Wasilczykb424da72018-11-15 11:52:57 -08001123 if (mode_id == feature_flags::chip_mode_ids::kV1Sta) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001124 success = mode_controller_.lock()->changeFirmwareMode(IfaceType::STA);
Tomasz Wasilczykb424da72018-11-15 11:52:57 -08001125 } else if (mode_id == feature_flags::chip_mode_ids::kV1Ap) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001126 success = mode_controller_.lock()->changeFirmwareMode(IfaceType::AP);
1127 }
1128 if (!success) {
1129 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
1130 }
1131 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->start();
1132 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1133 LOG(ERROR) << "Failed to start legacy HAL: "
1134 << legacyErrorToString(legacy_status);
1135 return createWifiStatusFromLegacyError(legacy_status);
1136 }
Roshan Pius85c64412018-01-22 17:58:40 -08001137 // Every time the HAL is restarted, we need to register the
1138 // radio mode change callback.
1139 WifiStatus status = registerRadioModeChangeCallback();
1140 if (status.code != WifiStatusCode::SUCCESS) {
1141 // This probably is not a critical failure?
1142 LOG(ERROR) << "Failed to register radio mode change callback";
1143 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001144 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius2c06a3f2016-12-15 17:51:40 -08001145}
Roshan Pius48185b22016-12-15 19:10:30 -08001146
1147WifiStatus WifiChip::registerDebugRingBufferCallback() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001148 if (debug_ring_buffer_cb_registered_) {
1149 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius48185b22016-12-15 19:10:30 -08001150 }
Roshan Pius3797e182017-03-30 18:01:54 -07001151
Roshan Piusabcf78f2017-10-06 16:30:38 -07001152 android::wp<WifiChip> weak_ptr_this(this);
1153 const auto& on_ring_buffer_data_callback =
xshu5899e8e2018-01-09 15:36:03 -08001154 [weak_ptr_this](const std::string& name,
Roshan Piusabcf78f2017-10-06 16:30:38 -07001155 const std::vector<uint8_t>& data,
1156 const legacy_hal::wifi_ring_buffer_status& status) {
1157 const auto shared_ptr_this = weak_ptr_this.promote();
1158 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
1159 LOG(ERROR) << "Callback invoked on an invalid object";
1160 return;
1161 }
1162 WifiDebugRingBufferStatus hidl_status;
1163 if (!hidl_struct_util::convertLegacyDebugRingBufferStatusToHidl(
1164 status, &hidl_status)) {
1165 LOG(ERROR) << "Error converting ring buffer status";
1166 return;
1167 }
xshu5899e8e2018-01-09 15:36:03 -08001168 const auto& target = shared_ptr_this->ringbuffer_map_.find(name);
1169 if (target != shared_ptr_this->ringbuffer_map_.end()) {
1170 Ringbuffer& cur_buffer = target->second;
1171 cur_buffer.append(data);
1172 } else {
1173 LOG(ERROR) << "Ringname " << name << " not found";
1174 return;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001175 }
1176 };
1177 legacy_hal::wifi_error legacy_status =
1178 legacy_hal_.lock()->registerRingBufferCallbackHandler(
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001179 getWlanIfaceName(0), on_ring_buffer_data_callback);
Roshan Pius48185b22016-12-15 19:10:30 -08001180
Roshan Piusabcf78f2017-10-06 16:30:38 -07001181 if (legacy_status == legacy_hal::WIFI_SUCCESS) {
1182 debug_ring_buffer_cb_registered_ = true;
1183 }
1184 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius48185b22016-12-15 19:10:30 -08001185}
1186
Roshan Pius85c64412018-01-22 17:58:40 -08001187WifiStatus WifiChip::registerRadioModeChangeCallback() {
1188 android::wp<WifiChip> weak_ptr_this(this);
1189 const auto& on_radio_mode_change_callback =
1190 [weak_ptr_this](const std::vector<legacy_hal::WifiMacInfo>& mac_infos) {
1191 const auto shared_ptr_this = weak_ptr_this.promote();
1192 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
1193 LOG(ERROR) << "Callback invoked on an invalid object";
1194 return;
1195 }
Jong Wook Kimda830c92018-07-23 15:29:38 -07001196 std::vector<V1_2::IWifiChipEventCallback::RadioModeInfo>
Roshan Pius85c64412018-01-22 17:58:40 -08001197 hidl_radio_mode_infos;
1198 if (!hidl_struct_util::convertLegacyWifiMacInfosToHidl(
1199 mac_infos, &hidl_radio_mode_infos)) {
1200 LOG(ERROR) << "Error converting wifi mac info";
1201 return;
1202 }
1203 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
1204 if (!callback->onRadioModeChange(hidl_radio_mode_infos)
1205 .isOk()) {
1206 LOG(ERROR) << "Failed to invoke onRadioModeChange"
1207 << " callback on: " << toString(callback);
1208 }
1209 }
1210 };
1211 legacy_hal::wifi_error legacy_status =
1212 legacy_hal_.lock()->registerRadioModeChangeCallbackHandler(
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001213 getWlanIfaceName(0), on_radio_mode_change_callback);
Roshan Pius85c64412018-01-22 17:58:40 -08001214 return createWifiStatusFromLegacyError(legacy_status);
1215}
1216
Roshan Piuscc338202017-11-02 13:54:09 -07001217std::vector<IWifiChip::ChipIfaceCombination>
1218WifiChip::getCurrentModeIfaceCombinations() {
1219 if (!isValidModeId(current_mode_id_)) {
1220 LOG(ERROR) << "Chip not configured in a mode yet";
1221 return {};
1222 }
1223 for (const auto& mode : modes_) {
1224 if (mode.id == current_mode_id_) {
1225 return mode.availableCombinations;
1226 }
1227 }
1228 CHECK(0) << "Expected to find iface combinations for current mode!";
1229 return {};
1230}
1231
1232// Returns a map indexed by IfaceType with the number of ifaces currently
1233// created of the corresponding type.
1234std::map<IfaceType, size_t> WifiChip::getCurrentIfaceCombination() {
1235 std::map<IfaceType, size_t> iface_counts;
1236 iface_counts[IfaceType::AP] = ap_ifaces_.size();
1237 iface_counts[IfaceType::NAN] = nan_ifaces_.size();
1238 iface_counts[IfaceType::P2P] = p2p_ifaces_.size();
1239 iface_counts[IfaceType::STA] = sta_ifaces_.size();
1240 return iface_counts;
1241}
1242
1243// This expands the provided iface combinations to a more parseable
1244// form. Returns a vector of available combinations possible with the number
1245// of ifaces of each type in the combination.
1246// This method is a port of HalDeviceManager.expandIfaceCombos() from framework.
1247std::vector<std::map<IfaceType, size_t>> WifiChip::expandIfaceCombinations(
1248 const IWifiChip::ChipIfaceCombination& combination) {
1249 uint32_t num_expanded_combos = 1;
1250 for (const auto& limit : combination.limits) {
1251 for (uint32_t i = 0; i < limit.maxIfaces; i++) {
1252 num_expanded_combos *= limit.types.size();
1253 }
1254 }
1255
1256 // Allocate the vector of expanded combos and reset all iface counts to 0
1257 // in each combo.
1258 std::vector<std::map<IfaceType, size_t>> expanded_combos;
1259 expanded_combos.resize(num_expanded_combos);
1260 for (auto& expanded_combo : expanded_combos) {
1261 for (const auto type :
1262 {IfaceType::AP, IfaceType::NAN, IfaceType::P2P, IfaceType::STA}) {
1263 expanded_combo[type] = 0;
1264 }
1265 }
1266 uint32_t span = num_expanded_combos;
1267 for (const auto& limit : combination.limits) {
1268 for (uint32_t i = 0; i < limit.maxIfaces; i++) {
1269 span /= limit.types.size();
1270 for (uint32_t k = 0; k < num_expanded_combos; ++k) {
1271 const auto iface_type =
1272 limit.types[(k / span) % limit.types.size()];
1273 expanded_combos[k][iface_type]++;
1274 }
1275 }
1276 }
1277 return expanded_combos;
1278}
1279
1280bool WifiChip::canExpandedIfaceCombinationSupportIfaceOfType(
1281 const std::map<IfaceType, size_t>& combo, IfaceType requested_type) {
1282 const auto current_combo = getCurrentIfaceCombination();
1283
1284 // Check if we have space for 1 more iface of |type| in this combo
1285 for (const auto type :
1286 {IfaceType::AP, IfaceType::NAN, IfaceType::P2P, IfaceType::STA}) {
1287 size_t num_ifaces_needed = current_combo.at(type);
1288 if (type == requested_type) {
1289 num_ifaces_needed++;
1290 }
1291 size_t num_ifaces_allowed = combo.at(type);
1292 if (num_ifaces_needed > num_ifaces_allowed) {
1293 return false;
1294 }
1295 }
1296 return true;
1297}
1298
1299// This method does the following:
1300// a) Enumerate all possible iface combos by expanding the current
1301// ChipIfaceCombination.
1302// b) Check if the requested iface type can be added to the current mode.
1303bool WifiChip::canCurrentModeSupportIfaceOfType(IfaceType type) {
1304 if (!isValidModeId(current_mode_id_)) {
1305 LOG(ERROR) << "Chip not configured in a mode yet";
1306 return false;
1307 }
1308 const auto combinations = getCurrentModeIfaceCombinations();
1309 for (const auto& combination : combinations) {
1310 const auto expanded_combos = expandIfaceCombinations(combination);
1311 for (const auto& expanded_combo : expanded_combos) {
1312 if (canExpandedIfaceCombinationSupportIfaceOfType(expanded_combo,
1313 type)) {
1314 return true;
1315 }
1316 }
1317 }
1318 return false;
1319}
1320
1321bool WifiChip::isValidModeId(ChipModeId mode_id) {
1322 for (const auto& mode : modes_) {
1323 if (mode.id == mode_id) {
1324 return true;
1325 }
1326 }
1327 return false;
1328}
1329
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001330// Return the first wlan (wlan0, wlan1 etc.) not already in use.
1331// This doesn't check the actual presence of these interfaces.
Roshan Pius8e3c7ef2017-11-03 09:43:08 -07001332std::string WifiChip::allocateApOrStaIfaceName() {
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001333 for (unsigned i = 0; i < kMaxWlanIfaces; i++) {
1334 const auto ifname = getWlanIfaceName(i);
1335 if (findUsingName(ap_ifaces_, ifname)) continue;
1336 if (findUsingName(sta_ifaces_, ifname)) continue;
1337 return ifname;
Roshan Pius8e3c7ef2017-11-03 09:43:08 -07001338 }
1339 // This should never happen. We screwed up somewhere if it did.
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001340 CHECK(false) << "All wlan interfaces in use already!";
Roshan Pius8e3c7ef2017-11-03 09:43:08 -07001341 return {};
1342}
1343
xshu5899e8e2018-01-09 15:36:03 -08001344bool WifiChip::writeRingbufferFilesInternal() {
1345 if (!removeOldFilesInternal()) {
1346 LOG(ERROR) << "Error occurred while deleting old tombstone files";
1347 return false;
1348 }
1349 // write ringbuffers to file
1350 for (const auto& item : ringbuffer_map_) {
1351 const Ringbuffer& cur_buffer = item.second;
1352 if (cur_buffer.getData().empty()) {
1353 continue;
1354 }
1355 const std::string file_path_raw =
1356 kTombstoneFolderPath + item.first + "XXXXXXXXXX";
1357 const int dump_fd = mkstemp(makeCharVec(file_path_raw).data());
1358 if (dump_fd == -1) {
1359 LOG(ERROR) << "create file failed: " << strerror(errno);
1360 return false;
1361 }
1362 unique_fd file_auto_closer(dump_fd);
1363 for (const auto& cur_block : cur_buffer.getData()) {
1364 if (write(dump_fd, cur_block.data(),
1365 sizeof(cur_block[0]) * cur_block.size()) == -1) {
1366 LOG(ERROR) << "Error writing to file " << strerror(errno);
1367 }
1368 }
1369 }
1370 return true;
1371}
1372
Roshan Pius79a99752016-10-04 13:03:58 -07001373} // namespace implementation
Jong Wook Kimda830c92018-07-23 15:29:38 -07001374} // namespace V1_3
Roshan Pius3c4e8a32016-10-03 14:53:58 -07001375} // namespace wifi
1376} // namespace hardware
1377} // namespace android