blob: 82d794ca163fdb29e6b6b103b18b7ead43986b85 [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>
lesl94d28242020-11-18 22:17:37 +080022#include <net/if.h>
xshu5899e8e2018-01-09 15:36:03 -080023#include <sys/stat.h>
24#include <sys/sysmacros.h>
Roshan Pius3c4e8a32016-10-03 14:53:58 -070025
Roshan Pius3c868522016-10-27 12:43:49 -070026#include "hidl_return_util.h"
Roshan Piuse2d0ab52016-12-05 15:24:20 -080027#include "hidl_struct_util.h"
Roshan Pius3c868522016-10-27 12:43:49 -070028#include "wifi_chip.h"
Roshan Pius5c055462016-10-11 08:27:27 -070029#include "wifi_status_util.h"
Roshan Pius3c4e8a32016-10-03 14:53:58 -070030
Roshan Pius35d958c2016-10-06 16:47:38 -070031namespace {
Jong Wook Kimda830c92018-07-23 15:29:38 -070032using android::sp;
xshu5899e8e2018-01-09 15:36:03 -080033using android::base::unique_fd;
Roshan Pius35d958c2016-10-06 16:47:38 -070034using android::hardware::hidl_string;
Roshan Piusabcf78f2017-10-06 16:30:38 -070035using android::hardware::hidl_vec;
Roshan Pius2c06a3f2016-12-15 17:51:40 -080036using android::hardware::wifi::V1_0::ChipModeId;
Roshan Pius52947fb2016-11-18 11:38:07 -080037using android::hardware::wifi::V1_0::IfaceType;
Roshan Pius675609b2017-10-31 14:24:58 -070038using android::hardware::wifi::V1_0::IWifiChip;
Roshan Pius52947fb2016-11-18 11:38:07 -080039
xshu5899e8e2018-01-09 15:36:03 -080040constexpr char kCpioMagic[] = "070701";
Roger Wangb294c762018-11-02 15:34:39 +080041constexpr size_t kMaxBufferSizeBytes = 1024 * 1024 * 3;
42constexpr uint32_t kMaxRingBufferFileAgeSeconds = 60 * 60 * 10;
xshu37126c92018-04-13 16:24:45 -070043constexpr uint32_t kMaxRingBufferFileNum = 20;
xshu5899e8e2018-01-09 15:36:03 -080044constexpr char kTombstoneFolderPath[] = "/data/vendor/tombstones/wifi/";
Roshan Pius8574e7f2019-04-01 13:30:40 -070045constexpr char kActiveWlanIfaceNameProperty[] = "wifi.active.interface";
46constexpr char kNoActiveWlanIfaceNamePropertyValue[] = "";
47constexpr unsigned kMaxWlanIfaces = 5;
lesl94d28242020-11-18 22:17:37 +080048constexpr char kApBridgeIfacePrefix[] = "ap_br_";
xshu5899e8e2018-01-09 15:36:03 -080049
Roshan Pius35d958c2016-10-06 16:47:38 -070050template <typename Iface>
Roshan Pius675609b2017-10-31 14:24:58 -070051void invalidateAndClear(std::vector<sp<Iface>>& ifaces, sp<Iface> iface) {
52 iface->invalidate();
53 ifaces.erase(std::remove(ifaces.begin(), ifaces.end(), iface),
54 ifaces.end());
55}
56
57template <typename Iface>
58void invalidateAndClearAll(std::vector<sp<Iface>>& ifaces) {
59 for (const auto& iface : ifaces) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070060 iface->invalidate();
Roshan Piusabcf78f2017-10-06 16:30:38 -070061 }
Roshan Pius675609b2017-10-31 14:24:58 -070062 ifaces.clear();
63}
64
65template <typename Iface>
66std::vector<hidl_string> getNames(std::vector<sp<Iface>>& ifaces) {
67 std::vector<hidl_string> names;
68 for (const auto& iface : ifaces) {
69 names.emplace_back(iface->getName());
70 }
71 return names;
72}
73
74template <typename Iface>
75sp<Iface> findUsingName(std::vector<sp<Iface>>& ifaces,
76 const std::string& name) {
77 std::vector<hidl_string> names;
78 for (const auto& iface : ifaces) {
79 if (name == iface->getName()) {
80 return iface;
81 }
82 }
83 return nullptr;
Roshan Pius35d958c2016-10-06 16:47:38 -070084}
Roshan Pius9377a0d2017-10-06 13:18:54 -070085
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -080086std::string getWlanIfaceName(unsigned idx) {
87 if (idx >= kMaxWlanIfaces) {
88 CHECK(false) << "Requested interface beyond wlan" << kMaxWlanIfaces;
89 return {};
90 }
Roshan Pius9377a0d2017-10-06 13:18:54 -070091
Roshan Pius8e3c7ef2017-11-03 09:43:08 -070092 std::array<char, PROPERTY_VALUE_MAX> buffer;
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -080093 if (idx == 0 || idx == 1) {
94 const char* altPropName =
95 (idx == 0) ? "wifi.interface" : "wifi.concurrent.interface";
Roshan Pius5b333462019-03-01 14:07:22 -080096 auto res = property_get(altPropName, buffer.data(), nullptr);
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -080097 if (res > 0) return buffer.data();
98 }
Roshan Pius5b333462019-03-01 14:07:22 -080099 std::string propName = "wifi.interface." + std::to_string(idx);
100 auto res = property_get(propName.c_str(), buffer.data(), nullptr);
101 if (res > 0) return buffer.data();
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800102
103 return "wlan" + std::to_string(idx);
Roshan Pius9377a0d2017-10-06 13:18:54 -0700104}
Roshan Pius9377a0d2017-10-06 13:18:54 -0700105
lesl261818b2020-11-27 12:37:35 +0800106// Returns the dedicated iface name if defined.
107// Returns two ifaces in bridged mode.
108std::vector<std::string> getPredefinedApIfaceNames(bool is_bridged) {
109 std::vector<std::string> ifnames;
Roshan Pius78cb5992020-04-30 12:39:21 -0700110 std::array<char, PROPERTY_VALUE_MAX> buffer;
lesl261818b2020-11-27 12:37:35 +0800111 buffer.fill(0);
Roshan Pius78cb5992020-04-30 12:39:21 -0700112 if (property_get("ro.vendor.wifi.sap.interface", buffer.data(), nullptr) ==
113 0) {
lesl261818b2020-11-27 12:37:35 +0800114 return ifnames;
Roshan Pius78cb5992020-04-30 12:39:21 -0700115 }
lesl261818b2020-11-27 12:37:35 +0800116 ifnames.push_back(buffer.data());
117 if (is_bridged) {
118 buffer.fill(0);
lesl5a46c952020-12-14 17:14:12 +0800119 if (property_get("ro.vendor.wifi.sap.concurrent.iface", buffer.data(),
120 nullptr) == 0) {
lesl261818b2020-11-27 12:37:35 +0800121 return ifnames;
122 }
123 ifnames.push_back(buffer.data());
124 }
125 return ifnames;
Roshan Pius78cb5992020-04-30 12:39:21 -0700126}
127
lesl261818b2020-11-27 12:37:35 +0800128std::string getPredefinedP2pIfaceName() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700129 std::array<char, PROPERTY_VALUE_MAX> buffer;
130 property_get("wifi.direct.interface", buffer.data(), "p2p0");
131 return buffer.data();
Roshan Pius9377a0d2017-10-06 13:18:54 -0700132}
133
Roshan Pius5ba0a902020-04-14 11:55:42 -0700134// Returns the dedicated iface name if one is defined.
lesl261818b2020-11-27 12:37:35 +0800135std::string getPredefinedNanIfaceName() {
Roshan Pius5ba0a902020-04-14 11:55:42 -0700136 std::array<char, PROPERTY_VALUE_MAX> buffer;
137 if (property_get("wifi.aware.interface", buffer.data(), nullptr) == 0) {
138 return {};
139 }
140 return buffer.data();
141}
142
Roshan Pius8574e7f2019-04-01 13:30:40 -0700143void setActiveWlanIfaceNameProperty(const std::string& ifname) {
144 auto res = property_set(kActiveWlanIfaceNameProperty, ifname.data());
145 if (res != 0) {
146 PLOG(ERROR) << "Failed to set active wlan iface name property";
147 }
148}
149
xshu37126c92018-04-13 16:24:45 -0700150// delete files that meet either conditions:
151// 1. older than a predefined time in the wifi tombstone dir.
152// 2. Files in excess to a predefined amount, starting from the oldest ones
xshu5899e8e2018-01-09 15:36:03 -0800153bool removeOldFilesInternal() {
154 time_t now = time(0);
155 const time_t delete_files_before = now - kMaxRingBufferFileAgeSeconds;
Josh Gaoa568e532018-06-04 18:16:00 -0700156 std::unique_ptr<DIR, decltype(&closedir)> dir_dump(
157 opendir(kTombstoneFolderPath), closedir);
xshu5899e8e2018-01-09 15:36:03 -0800158 if (!dir_dump) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800159 PLOG(ERROR) << "Failed to open directory";
xshu5899e8e2018-01-09 15:36:03 -0800160 return false;
161 }
xshu5899e8e2018-01-09 15:36:03 -0800162 struct dirent* dp;
163 bool success = true;
xshu37126c92018-04-13 16:24:45 -0700164 std::list<std::pair<const time_t, std::string>> valid_files;
Josh Gaoa568e532018-06-04 18:16:00 -0700165 while ((dp = readdir(dir_dump.get()))) {
xshu5899e8e2018-01-09 15:36:03 -0800166 if (dp->d_type != DT_REG) {
167 continue;
168 }
169 std::string cur_file_name(dp->d_name);
170 struct stat cur_file_stat;
171 std::string cur_file_path = kTombstoneFolderPath + cur_file_name;
xshu4cb33162018-01-24 15:40:06 -0800172 if (stat(cur_file_path.c_str(), &cur_file_stat) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800173 PLOG(ERROR) << "Failed to get file stat for " << cur_file_path;
xshu5899e8e2018-01-09 15:36:03 -0800174 success = false;
xshu4cb33162018-01-24 15:40:06 -0800175 continue;
176 }
xshu37126c92018-04-13 16:24:45 -0700177 const time_t cur_file_time = cur_file_stat.st_mtime;
178 valid_files.push_back(
179 std::pair<const time_t, std::string>(cur_file_time, cur_file_path));
180 }
181 valid_files.sort(); // sort the list of files by last modified time from
182 // small to big.
183 uint32_t cur_file_count = valid_files.size();
184 for (auto cur_file : valid_files) {
185 if (cur_file_count > kMaxRingBufferFileNum ||
186 cur_file.first < delete_files_before) {
187 if (unlink(cur_file.second.c_str()) != 0) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800188 PLOG(ERROR) << "Error deleting file";
xshu37126c92018-04-13 16:24:45 -0700189 success = false;
190 }
191 cur_file_count--;
192 } else {
193 break;
xshu5899e8e2018-01-09 15:36:03 -0800194 }
195 }
196 return success;
197}
198
xshu4cb33162018-01-24 15:40:06 -0800199// Helper function for |cpioArchiveFilesInDir|
200bool cpioWriteHeader(int out_fd, struct stat& st, const char* file_name,
201 size_t file_name_len) {
202 std::array<char, 32 * 1024> read_buf;
203 ssize_t llen =
204 sprintf(read_buf.data(),
205 "%s%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X",
206 kCpioMagic, static_cast<int>(st.st_ino), st.st_mode, st.st_uid,
207 st.st_gid, static_cast<int>(st.st_nlink),
208 static_cast<int>(st.st_mtime), static_cast<int>(st.st_size),
209 major(st.st_dev), minor(st.st_dev), major(st.st_rdev),
210 minor(st.st_rdev), static_cast<uint32_t>(file_name_len), 0);
211 if (write(out_fd, read_buf.data(), llen) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800212 PLOG(ERROR) << "Error writing cpio header to file " << file_name;
xshu4cb33162018-01-24 15:40:06 -0800213 return false;
214 }
215 if (write(out_fd, file_name, file_name_len) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800216 PLOG(ERROR) << "Error writing filename to file " << file_name;
xshu4cb33162018-01-24 15:40:06 -0800217 return false;
218 }
219
220 // NUL Pad header up to 4 multiple bytes.
221 llen = (llen + file_name_len) % 4;
222 if (llen != 0) {
223 const uint32_t zero = 0;
224 if (write(out_fd, &zero, 4 - llen) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800225 PLOG(ERROR) << "Error padding 0s to file " << file_name;
xshu4cb33162018-01-24 15:40:06 -0800226 return false;
227 }
228 }
229 return true;
230}
231
232// Helper function for |cpioArchiveFilesInDir|
233size_t cpioWriteFileContent(int fd_read, int out_fd, struct stat& st) {
234 // writing content of file
235 std::array<char, 32 * 1024> read_buf;
236 ssize_t llen = st.st_size;
237 size_t n_error = 0;
238 while (llen > 0) {
239 ssize_t bytes_read = read(fd_read, read_buf.data(), read_buf.size());
240 if (bytes_read == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800241 PLOG(ERROR) << "Error reading file";
xshu4cb33162018-01-24 15:40:06 -0800242 return ++n_error;
243 }
244 llen -= bytes_read;
245 if (write(out_fd, read_buf.data(), bytes_read) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800246 PLOG(ERROR) << "Error writing data to file";
xshu4cb33162018-01-24 15:40:06 -0800247 return ++n_error;
248 }
249 if (bytes_read == 0) { // this should never happen, but just in case
250 // to unstuck from while loop
Elliott Hughes4db4add2019-03-08 12:42:57 -0800251 PLOG(ERROR) << "Unexpected read result";
xshu4cb33162018-01-24 15:40:06 -0800252 n_error++;
253 break;
254 }
255 }
256 llen = st.st_size % 4;
257 if (llen != 0) {
258 const uint32_t zero = 0;
259 if (write(out_fd, &zero, 4 - llen) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800260 PLOG(ERROR) << "Error padding 0s to file";
xshu4cb33162018-01-24 15:40:06 -0800261 return ++n_error;
262 }
263 }
264 return n_error;
265}
266
267// Helper function for |cpioArchiveFilesInDir|
268bool cpioWriteFileTrailer(int out_fd) {
269 std::array<char, 4096> read_buf;
270 read_buf.fill(0);
271 if (write(out_fd, read_buf.data(),
272 sprintf(read_buf.data(), "070701%040X%056X%08XTRAILER!!!", 1,
273 0x0b, 0) +
274 4) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800275 PLOG(ERROR) << "Error writing trailing bytes";
xshu4cb33162018-01-24 15:40:06 -0800276 return false;
277 }
278 return true;
279}
280
xshu5899e8e2018-01-09 15:36:03 -0800281// Archives all files in |input_dir| and writes result into |out_fd|
282// Logic obtained from //external/toybox/toys/posix/cpio.c "Output cpio archive"
283// portion
xshu4cb33162018-01-24 15:40:06 -0800284size_t cpioArchiveFilesInDir(int out_fd, const char* input_dir) {
xshu5899e8e2018-01-09 15:36:03 -0800285 struct dirent* dp;
286 size_t n_error = 0;
Josh Gaoa568e532018-06-04 18:16:00 -0700287 std::unique_ptr<DIR, decltype(&closedir)> dir_dump(opendir(input_dir),
288 closedir);
xshu5899e8e2018-01-09 15:36:03 -0800289 if (!dir_dump) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800290 PLOG(ERROR) << "Failed to open directory";
xshu4cb33162018-01-24 15:40:06 -0800291 return ++n_error;
xshu5899e8e2018-01-09 15:36:03 -0800292 }
Josh Gaoa568e532018-06-04 18:16:00 -0700293 while ((dp = readdir(dir_dump.get()))) {
xshu5899e8e2018-01-09 15:36:03 -0800294 if (dp->d_type != DT_REG) {
295 continue;
296 }
297 std::string cur_file_name(dp->d_name);
xshu5899e8e2018-01-09 15:36:03 -0800298 struct stat st;
xshu5899e8e2018-01-09 15:36:03 -0800299 const std::string cur_file_path = kTombstoneFolderPath + cur_file_name;
xshu4cb33162018-01-24 15:40:06 -0800300 if (stat(cur_file_path.c_str(), &st) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800301 PLOG(ERROR) << "Failed to get file stat for " << cur_file_path;
xshu5899e8e2018-01-09 15:36:03 -0800302 n_error++;
xshu4cb33162018-01-24 15:40:06 -0800303 continue;
304 }
305 const int fd_read = open(cur_file_path.c_str(), O_RDONLY);
306 if (fd_read == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800307 PLOG(ERROR) << "Failed to open file " << cur_file_path;
xshu4cb33162018-01-24 15:40:06 -0800308 n_error++;
309 continue;
310 }
xshuf392fb42020-08-13 16:57:00 -0700311 std::string file_name_with_last_modified_time =
312 cur_file_name + "-" + std::to_string(st.st_mtime);
313 // string.size() does not include the null terminator. The cpio FreeBSD
314 // file header expects the null character to be included in the length.
315 const size_t file_name_len =
316 file_name_with_last_modified_time.size() + 1;
xshu4cb33162018-01-24 15:40:06 -0800317 unique_fd file_auto_closer(fd_read);
xshuf392fb42020-08-13 16:57:00 -0700318 if (!cpioWriteHeader(out_fd, st,
319 file_name_with_last_modified_time.c_str(),
xshu4cb33162018-01-24 15:40:06 -0800320 file_name_len)) {
321 return ++n_error;
322 }
323 size_t write_error = cpioWriteFileContent(fd_read, out_fd, st);
324 if (write_error) {
325 return n_error + write_error;
xshu5899e8e2018-01-09 15:36:03 -0800326 }
327 }
xshu4cb33162018-01-24 15:40:06 -0800328 if (!cpioWriteFileTrailer(out_fd)) {
329 return ++n_error;
xshu5899e8e2018-01-09 15:36:03 -0800330 }
331 return n_error;
332}
333
334// Helper function to create a non-const char*.
335std::vector<char> makeCharVec(const std::string& str) {
336 std::vector<char> vec(str.size() + 1);
337 vec.assign(str.begin(), str.end());
338 vec.push_back('\0');
339 return vec;
340}
341
Roshan Piusabcf78f2017-10-06 16:30:38 -0700342} // namespace
Roshan Pius35d958c2016-10-06 16:47:38 -0700343
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700344namespace android {
345namespace hardware {
346namespace wifi {
Jimmy Chend460df32019-11-29 17:31:22 +0200347namespace V1_5 {
Roshan Pius79a99752016-10-04 13:03:58 -0700348namespace implementation {
Roshan Pius3c868522016-10-27 12:43:49 -0700349using hidl_return_util::validateAndCall;
Roshan Piusba38d9c2017-12-08 07:32:08 -0800350using hidl_return_util::validateAndCallWithLock;
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700351
Roshan Pius52947fb2016-11-18 11:38:07 -0800352WifiChip::WifiChip(
Jimmy Chen2dddd792019-12-23 17:50:39 +0200353 ChipId chip_id, bool is_primary,
354 const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
Roshan Pius200a17d2017-11-01 13:03:35 -0700355 const std::weak_ptr<mode_controller::WifiModeController> mode_controller,
Roshan Pius8c1a67b2021-03-02 10:00:23 -0800356 const std::shared_ptr<iface_util::WifiIfaceUtil> iface_util,
Ahmed ElArabawy2134bf72020-06-18 15:07:12 -0700357 const std::weak_ptr<feature_flags::WifiFeatureFlags> feature_flags,
358 const std::function<void(const std::string&)>& handler)
Roshan Pius52947fb2016-11-18 11:38:07 -0800359 : chip_id_(chip_id),
360 legacy_hal_(legacy_hal),
361 mode_controller_(mode_controller),
Roshan Pius99dab382019-02-14 07:57:10 -0800362 iface_util_(iface_util),
Roshan Pius52947fb2016-11-18 11:38:07 -0800363 is_valid_(true),
Tomasz Wasilczykb424da72018-11-15 11:52:57 -0800364 current_mode_id_(feature_flags::chip_mode_ids::kInvalid),
Jimmy Chen2dddd792019-12-23 17:50:39 +0200365 modes_(feature_flags.lock()->getChipModes(is_primary)),
Ahmed ElArabawy2134bf72020-06-18 15:07:12 -0700366 debug_ring_buffer_cb_registered_(false),
367 subsystemCallbackHandler_(handler) {
Roshan Pius8574e7f2019-04-01 13:30:40 -0700368 setActiveWlanIfaceNameProperty(kNoActiveWlanIfaceNamePropertyValue);
369}
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700370
Roshan Piusaabe5752016-09-29 09:03:59 -0700371void WifiChip::invalidate() {
xshu37126c92018-04-13 16:24:45 -0700372 if (!writeRingbufferFilesInternal()) {
373 LOG(ERROR) << "Error writing files to flash";
374 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700375 invalidateAndRemoveAllIfaces();
Roshan Pius8574e7f2019-04-01 13:30:40 -0700376 setActiveWlanIfaceNameProperty(kNoActiveWlanIfaceNamePropertyValue);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700377 legacy_hal_.reset();
378 event_cb_handler_.invalidate();
379 is_valid_ = false;
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700380}
381
Roshan Piusabcf78f2017-10-06 16:30:38 -0700382bool WifiChip::isValid() { return is_valid_; }
Roshan Pius3c868522016-10-27 12:43:49 -0700383
Jimmy Chend460df32019-11-29 17:31:22 +0200384std::set<sp<V1_4::IWifiChipEventCallback>> WifiChip::getEventCallbacks() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700385 return event_cb_handler_.getCallbacks();
Roshan Pius203cb032016-12-14 17:41:20 -0800386}
387
Roshan Pius5c055462016-10-11 08:27:27 -0700388Return<void> WifiChip::getId(getId_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700389 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
390 &WifiChip::getIdInternal, hidl_status_cb);
Roshan Piuscd566bd2016-10-10 08:03:42 -0700391}
392
Jong Wook Kimda830c92018-07-23 15:29:38 -0700393// Deprecated support for this callback
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700394Return<void> WifiChip::registerEventCallback(
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800395 const sp<V1_0::IWifiChipEventCallback>& event_callback,
Roshan Pius5c055462016-10-11 08:27:27 -0700396 registerEventCallback_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700397 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
398 &WifiChip::registerEventCallbackInternal,
399 hidl_status_cb, event_callback);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700400}
401
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700402Return<void> WifiChip::getCapabilities(getCapabilities_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700403 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
404 &WifiChip::getCapabilitiesInternal, hidl_status_cb);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700405}
406
Roshan Pius5c055462016-10-11 08:27:27 -0700407Return<void> WifiChip::getAvailableModes(getAvailableModes_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700408 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
409 &WifiChip::getAvailableModesInternal,
410 hidl_status_cb);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700411}
412
Roshan Pius2c06a3f2016-12-15 17:51:40 -0800413Return<void> WifiChip::configureChip(ChipModeId mode_id,
Roshan Pius5c055462016-10-11 08:27:27 -0700414 configureChip_cb hidl_status_cb) {
Roshan Piusba38d9c2017-12-08 07:32:08 -0800415 return validateAndCallWithLock(
416 this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
417 &WifiChip::configureChipInternal, hidl_status_cb, mode_id);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700418}
419
Roshan Pius5c055462016-10-11 08:27:27 -0700420Return<void> WifiChip::getMode(getMode_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700421 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
422 &WifiChip::getModeInternal, hidl_status_cb);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700423}
424
Roshan Pius5c055462016-10-11 08:27:27 -0700425Return<void> WifiChip::requestChipDebugInfo(
426 requestChipDebugInfo_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700427 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
428 &WifiChip::requestChipDebugInfoInternal,
429 hidl_status_cb);
Roshan Pius5c055462016-10-11 08:27:27 -0700430}
431
432Return<void> WifiChip::requestDriverDebugDump(
433 requestDriverDebugDump_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700434 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
435 &WifiChip::requestDriverDebugDumpInternal,
436 hidl_status_cb);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700437}
438
Roshan Pius5c055462016-10-11 08:27:27 -0700439Return<void> WifiChip::requestFirmwareDebugDump(
440 requestFirmwareDebugDump_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700441 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
442 &WifiChip::requestFirmwareDebugDumpInternal,
443 hidl_status_cb);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700444}
445
Roshan Pius5c055462016-10-11 08:27:27 -0700446Return<void> WifiChip::createApIface(createApIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700447 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
448 &WifiChip::createApIfaceInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700449}
450
lesl94d28242020-11-18 22:17:37 +0800451Return<void> WifiChip::createBridgedApIface(
452 createBridgedApIface_cb hidl_status_cb) {
453 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
454 &WifiChip::createBridgedApIfaceInternal,
455 hidl_status_cb);
456}
457
Roshan Pius5c055462016-10-11 08:27:27 -0700458Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700459 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
460 &WifiChip::getApIfaceNamesInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700461}
462
Roshan Pius5c055462016-10-11 08:27:27 -0700463Return<void> WifiChip::getApIface(const hidl_string& ifname,
464 getApIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700465 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
466 &WifiChip::getApIfaceInternal, hidl_status_cb,
467 ifname);
Roshan Pius35d958c2016-10-06 16:47:38 -0700468}
469
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800470Return<void> WifiChip::removeApIface(const hidl_string& ifname,
471 removeApIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700472 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
473 &WifiChip::removeApIfaceInternal, hidl_status_cb,
474 ifname);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800475}
476
lesl94d28242020-11-18 22:17:37 +0800477Return<void> WifiChip::removeIfaceInstanceFromBridgedApIface(
478 const hidl_string& ifname, const hidl_string& ifInstanceName,
479 removeIfaceInstanceFromBridgedApIface_cb hidl_status_cb) {
480 return validateAndCall(
481 this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
482 &WifiChip::removeIfaceInstanceFromBridgedApIfaceInternal,
483 hidl_status_cb, ifname, ifInstanceName);
484}
485
Roshan Pius5c055462016-10-11 08:27:27 -0700486Return<void> WifiChip::createNanIface(createNanIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700487 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
488 &WifiChip::createNanIfaceInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700489}
490
Roshan Pius5c055462016-10-11 08:27:27 -0700491Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700492 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
493 &WifiChip::getNanIfaceNamesInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700494}
495
496Return<void> WifiChip::getNanIface(const hidl_string& ifname,
Roshan Pius5c055462016-10-11 08:27:27 -0700497 getNanIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700498 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
499 &WifiChip::getNanIfaceInternal, hidl_status_cb,
500 ifname);
Roshan Pius35d958c2016-10-06 16:47:38 -0700501}
502
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800503Return<void> WifiChip::removeNanIface(const hidl_string& ifname,
504 removeNanIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700505 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
506 &WifiChip::removeNanIfaceInternal, hidl_status_cb,
507 ifname);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800508}
509
Roshan Pius5c055462016-10-11 08:27:27 -0700510Return<void> WifiChip::createP2pIface(createP2pIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700511 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
512 &WifiChip::createP2pIfaceInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700513}
514
Roshan Pius5c055462016-10-11 08:27:27 -0700515Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700516 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
517 &WifiChip::getP2pIfaceNamesInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700518}
519
520Return<void> WifiChip::getP2pIface(const hidl_string& ifname,
Roshan Pius5c055462016-10-11 08:27:27 -0700521 getP2pIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700522 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
523 &WifiChip::getP2pIfaceInternal, hidl_status_cb,
524 ifname);
Roshan Pius35d958c2016-10-06 16:47:38 -0700525}
526
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800527Return<void> WifiChip::removeP2pIface(const hidl_string& ifname,
528 removeP2pIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700529 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
530 &WifiChip::removeP2pIfaceInternal, hidl_status_cb,
531 ifname);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800532}
533
Roshan Pius5c055462016-10-11 08:27:27 -0700534Return<void> WifiChip::createStaIface(createStaIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700535 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
536 &WifiChip::createStaIfaceInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700537}
538
Roshan Pius5c055462016-10-11 08:27:27 -0700539Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700540 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
541 &WifiChip::getStaIfaceNamesInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700542}
543
544Return<void> WifiChip::getStaIface(const hidl_string& ifname,
Roshan Pius5c055462016-10-11 08:27:27 -0700545 getStaIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700546 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
547 &WifiChip::getStaIfaceInternal, hidl_status_cb,
548 ifname);
Roshan Pius35d958c2016-10-06 16:47:38 -0700549}
550
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800551Return<void> WifiChip::removeStaIface(const hidl_string& ifname,
552 removeStaIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700553 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
554 &WifiChip::removeStaIfaceInternal, hidl_status_cb,
555 ifname);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800556}
557
Roshan Pius5c055462016-10-11 08:27:27 -0700558Return<void> WifiChip::createRttController(
559 const sp<IWifiIface>& bound_iface, createRttController_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700560 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
561 &WifiChip::createRttControllerInternal,
562 hidl_status_cb, bound_iface);
Roshan Pius59268282016-10-06 20:23:47 -0700563}
564
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700565Return<void> WifiChip::getDebugRingBuffersStatus(
566 getDebugRingBuffersStatus_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700567 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
568 &WifiChip::getDebugRingBuffersStatusInternal,
569 hidl_status_cb);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700570}
571
572Return<void> WifiChip::startLoggingToDebugRingBuffer(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700573 const hidl_string& ring_name, WifiDebugRingBufferVerboseLevel verbose_level,
574 uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes,
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700575 startLoggingToDebugRingBuffer_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700576 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
577 &WifiChip::startLoggingToDebugRingBufferInternal,
578 hidl_status_cb, ring_name, verbose_level,
579 max_interval_in_sec, min_data_size_in_bytes);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700580}
581
582Return<void> WifiChip::forceDumpToDebugRingBuffer(
583 const hidl_string& ring_name,
584 forceDumpToDebugRingBuffer_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700585 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
586 &WifiChip::forceDumpToDebugRingBufferInternal,
587 hidl_status_cb, ring_name);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700588}
589
Roger Wangb294c762018-11-02 15:34:39 +0800590Return<void> WifiChip::flushRingBufferToFile(
591 flushRingBufferToFile_cb hidl_status_cb) {
592 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
593 &WifiChip::flushRingBufferToFileInternal,
594 hidl_status_cb);
595}
596
Roshan Pius8c0c8e92017-02-24 08:07:42 -0800597Return<void> WifiChip::stopLoggingToDebugRingBuffer(
598 stopLoggingToDebugRingBuffer_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700599 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
600 &WifiChip::stopLoggingToDebugRingBufferInternal,
601 hidl_status_cb);
Roshan Pius8c0c8e92017-02-24 08:07:42 -0800602}
603
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700604Return<void> WifiChip::getDebugHostWakeReasonStats(
605 getDebugHostWakeReasonStats_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700606 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
607 &WifiChip::getDebugHostWakeReasonStatsInternal,
608 hidl_status_cb);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700609}
610
Roshan Pius203cb032016-12-14 17:41:20 -0800611Return<void> WifiChip::enableDebugErrorAlerts(
612 bool enable, enableDebugErrorAlerts_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700613 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
614 &WifiChip::enableDebugErrorAlertsInternal,
615 hidl_status_cb, enable);
Roshan Pius203cb032016-12-14 17:41:20 -0800616}
617
Roshan Pius735ff432017-07-25 08:48:08 -0700618Return<void> WifiChip::selectTxPowerScenario(
Jong Wook Kimda830c92018-07-23 15:29:38 -0700619 V1_1::IWifiChip::TxPowerScenario scenario,
620 selectTxPowerScenario_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700621 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
622 &WifiChip::selectTxPowerScenarioInternal,
623 hidl_status_cb, scenario);
Roshan Piusdbd83ef2017-06-20 12:05:40 -0700624}
625
Roshan Pius735ff432017-07-25 08:48:08 -0700626Return<void> WifiChip::resetTxPowerScenario(
627 resetTxPowerScenario_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700628 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
629 &WifiChip::resetTxPowerScenarioInternal,
630 hidl_status_cb);
Roshan Piusdbd83ef2017-06-20 12:05:40 -0700631}
632
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700633Return<void> WifiChip::setLatencyMode(LatencyMode mode,
634 setLatencyMode_cb hidl_status_cb) {
635 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
636 &WifiChip::setLatencyModeInternal, hidl_status_cb,
637 mode);
638}
639
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800640Return<void> WifiChip::registerEventCallback_1_2(
Jong Wook Kimda830c92018-07-23 15:29:38 -0700641 const sp<V1_2::IWifiChipEventCallback>& event_callback,
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800642 registerEventCallback_cb hidl_status_cb) {
643 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
644 &WifiChip::registerEventCallbackInternal_1_2,
645 hidl_status_cb, event_callback);
646}
647
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800648Return<void> WifiChip::selectTxPowerScenario_1_2(
Jong Wook Kimda830c92018-07-23 15:29:38 -0700649 TxPowerScenario scenario, selectTxPowerScenario_cb hidl_status_cb) {
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800650 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
Jong Wook Kimda830c92018-07-23 15:29:38 -0700651 &WifiChip::selectTxPowerScenarioInternal_1_2,
652 hidl_status_cb, scenario);
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800653}
654
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700655Return<void> WifiChip::getCapabilities_1_3(getCapabilities_cb hidl_status_cb) {
656 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
657 &WifiChip::getCapabilitiesInternal_1_3,
658 hidl_status_cb);
659}
660
Jimmy Chen1bdf1a72019-12-23 17:53:40 +0200661Return<void> WifiChip::getCapabilities_1_5(
662 getCapabilities_1_5_cb hidl_status_cb) {
663 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
664 &WifiChip::getCapabilitiesInternal_1_5,
665 hidl_status_cb);
666}
667
xshu5899e8e2018-01-09 15:36:03 -0800668Return<void> WifiChip::debug(const hidl_handle& handle,
669 const hidl_vec<hidl_string>&) {
670 if (handle != nullptr && handle->numFds >= 1) {
xshu0a0fe512020-07-22 17:53:37 -0700671 {
672 std::unique_lock<std::mutex> lk(lock_t);
673 for (const auto& item : ringbuffer_map_) {
674 forceDumpToDebugRingBufferInternal(item.first);
675 }
676 // unique_lock unlocked here
677 }
678 usleep(100 * 1000); // sleep for 100 milliseconds to wait for
679 // ringbuffer updates.
xshu5899e8e2018-01-09 15:36:03 -0800680 int fd = handle->data[0];
681 if (!writeRingbufferFilesInternal()) {
682 LOG(ERROR) << "Error writing files to flash";
683 }
xshu4cb33162018-01-24 15:40:06 -0800684 uint32_t n_error = cpioArchiveFilesInDir(fd, kTombstoneFolderPath);
xshu5899e8e2018-01-09 15:36:03 -0800685 if (n_error != 0) {
686 LOG(ERROR) << n_error << " errors occured in cpio function";
687 }
688 fsync(fd);
689 } else {
690 LOG(ERROR) << "File handle error";
691 }
692 return Void();
693}
694
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -0700695Return<void> WifiChip::createRttController_1_4(
696 const sp<IWifiIface>& bound_iface,
697 createRttController_1_4_cb hidl_status_cb) {
698 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
699 &WifiChip::createRttControllerInternal_1_4,
700 hidl_status_cb, bound_iface);
701}
702
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800703Return<void> WifiChip::registerEventCallback_1_4(
Jimmy Chend460df32019-11-29 17:31:22 +0200704 const sp<V1_4::IWifiChipEventCallback>& event_callback,
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800705 registerEventCallback_cb hidl_status_cb) {
706 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
707 &WifiChip::registerEventCallbackInternal_1_4,
708 hidl_status_cb, event_callback);
709}
710
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800711Return<void> WifiChip::setMultiStaPrimaryConnection(
712 const hidl_string& ifname, setMultiStaPrimaryConnection_cb hidl_status_cb) {
713 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
714 &WifiChip::setMultiStaPrimaryConnectionInternal,
715 hidl_status_cb, ifname);
716}
717
718Return<void> WifiChip::setMultiStaUseCase(
719 MultiStaUseCase use_case, setMultiStaUseCase_cb hidl_status_cb) {
720 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
721 &WifiChip::setMultiStaUseCaseInternal,
722 hidl_status_cb, use_case);
723}
724
Quang Luong94bcce52020-11-25 17:52:19 -0800725Return<void> WifiChip::setCoexUnsafeChannels(
726 const hidl_vec<CoexUnsafeChannel>& unsafeChannels,
Quang Luongab70a832020-12-14 13:01:32 -0800727 hidl_bitfield<CoexRestriction> restrictions,
Quang Luong94bcce52020-11-25 17:52:19 -0800728 setCoexUnsafeChannels_cb hidl_status_cb) {
729 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
730 &WifiChip::setCoexUnsafeChannelsInternal,
731 hidl_status_cb, unsafeChannels, restrictions);
732}
733
Kumar Anandda62c382020-11-18 17:17:47 -0800734Return<void> WifiChip::setCountryCode(const hidl_array<int8_t, 2>& code,
735 setCountryCode_cb hidl_status_cb) {
736 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
737 &WifiChip::setCountryCodeInternal, hidl_status_cb,
738 code);
739}
740
Kumar Anand2a630a32021-01-21 14:09:14 -0800741Return<void> WifiChip::getUsableChannels(
742 WifiBand band, hidl_bitfield<WifiIfaceMode> ifaceModeMask,
Kumar Anandaea86e02021-02-10 16:22:31 -0800743 hidl_bitfield<UsableChannelFilter> filterMask,
Kumar Anand2a630a32021-01-21 14:09:14 -0800744 getUsableChannels_cb _hidl_cb) {
745 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
746 &WifiChip::getUsableChannelsInternal, _hidl_cb, band,
Kumar Anandaea86e02021-02-10 16:22:31 -0800747 ifaceModeMask, filterMask);
Kumar Anand2a630a32021-01-21 14:09:14 -0800748}
749
chenpaulc6f57032021-03-05 17:06:50 +0800750Return<void> WifiChip::triggerSubsystemRestart(
751 triggerSubsystemRestart_cb hidl_status_cb) {
752 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
753 &WifiChip::triggerSubsystemRestartInternal,
754 hidl_status_cb);
755}
756
Roshan Pius35d958c2016-10-06 16:47:38 -0700757void WifiChip::invalidateAndRemoveAllIfaces() {
lesl94d28242020-11-18 22:17:37 +0800758 invalidateAndClearBridgedApAll();
Roshan Pius675609b2017-10-31 14:24:58 -0700759 invalidateAndClearAll(ap_ifaces_);
760 invalidateAndClearAll(nan_ifaces_);
761 invalidateAndClearAll(p2p_ifaces_);
762 invalidateAndClearAll(sta_ifaces_);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700763 // Since all the ifaces are invalid now, all RTT controller objects
764 // using those ifaces also need to be invalidated.
765 for (const auto& rtt : rtt_controllers_) {
766 rtt->invalidate();
767 }
768 rtt_controllers_.clear();
Roshan Pius35d958c2016-10-06 16:47:38 -0700769}
770
Roshan Pius82368502019-05-16 12:53:02 -0700771void WifiChip::invalidateAndRemoveDependencies(
772 const std::string& removed_iface_name) {
Jimmy Chen7a82ad82019-11-29 17:31:22 +0200773 for (auto it = nan_ifaces_.begin(); it != nan_ifaces_.end();) {
774 auto nan_iface = *it;
Roshan Pius82368502019-05-16 12:53:02 -0700775 if (nan_iface->getName() == removed_iface_name) {
Jimmy Chen7a82ad82019-11-29 17:31:22 +0200776 nan_iface->invalidate();
Roshan Pius82368502019-05-16 12:53:02 -0700777 for (const auto& callback : event_cb_handler_.getCallbacks()) {
778 if (!callback
779 ->onIfaceRemoved(IfaceType::NAN, removed_iface_name)
780 .isOk()) {
781 LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
782 }
783 }
Jimmy Chen7a82ad82019-11-29 17:31:22 +0200784 it = nan_ifaces_.erase(it);
785 } else {
786 ++it;
Roshan Pius82368502019-05-16 12:53:02 -0700787 }
788 }
Jimmy Chen7a82ad82019-11-29 17:31:22 +0200789
790 for (auto it = rtt_controllers_.begin(); it != rtt_controllers_.end();) {
791 auto rtt = *it;
Roshan Pius82368502019-05-16 12:53:02 -0700792 if (rtt->getIfaceName() == removed_iface_name) {
Jimmy Chen7a82ad82019-11-29 17:31:22 +0200793 rtt->invalidate();
794 it = rtt_controllers_.erase(it);
795 } else {
796 ++it;
Roshan Pius82368502019-05-16 12:53:02 -0700797 }
798 }
799}
800
Roshan Pius3c868522016-10-27 12:43:49 -0700801std::pair<WifiStatus, ChipId> WifiChip::getIdInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700802 return {createWifiStatus(WifiStatusCode::SUCCESS), chip_id_};
Roshan Pius3c868522016-10-27 12:43:49 -0700803}
804
805WifiStatus WifiChip::registerEventCallbackInternal(
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800806 const sp<V1_0::IWifiChipEventCallback>& /* event_callback */) {
807 // Deprecated support for this callback.
808 return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
Roshan Pius3c868522016-10-27 12:43:49 -0700809}
810
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700811std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal() {
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700812 // Deprecated support for this callback.
813 return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), 0};
814}
815
Jimmy Chend460df32019-11-29 17:31:22 +0200816std::pair<WifiStatus, std::vector<V1_4::IWifiChip::ChipMode>>
Roshan Pius3c868522016-10-27 12:43:49 -0700817WifiChip::getAvailableModesInternal() {
Roshan Piuscc338202017-11-02 13:54:09 -0700818 return {createWifiStatus(WifiStatusCode::SUCCESS), modes_};
Roshan Pius3c868522016-10-27 12:43:49 -0700819}
820
Roshan Piusba38d9c2017-12-08 07:32:08 -0800821WifiStatus WifiChip::configureChipInternal(
822 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock,
823 ChipModeId mode_id) {
Roshan Piuscc338202017-11-02 13:54:09 -0700824 if (!isValidModeId(mode_id)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700825 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
826 }
827 if (mode_id == current_mode_id_) {
828 LOG(DEBUG) << "Already in the specified mode " << mode_id;
829 return createWifiStatus(WifiStatusCode::SUCCESS);
830 }
Roshan Piusba38d9c2017-12-08 07:32:08 -0800831 WifiStatus status = handleChipConfiguration(lock, mode_id);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700832 if (status.code != WifiStatusCode::SUCCESS) {
833 for (const auto& callback : event_cb_handler_.getCallbacks()) {
834 if (!callback->onChipReconfigureFailure(status).isOk()) {
835 LOG(ERROR)
836 << "Failed to invoke onChipReconfigureFailure callback";
837 }
838 }
839 return status;
840 }
Roshan Piusd37341f2017-01-31 13:13:28 -0800841 for (const auto& callback : event_cb_handler_.getCallbacks()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700842 if (!callback->onChipReconfigured(mode_id).isOk()) {
843 LOG(ERROR) << "Failed to invoke onChipReconfigured callback";
844 }
Roshan Pius52947fb2016-11-18 11:38:07 -0800845 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700846 current_mode_id_ = mode_id;
Roshan Piusba38d9c2017-12-08 07:32:08 -0800847 LOG(INFO) << "Configured chip in mode " << mode_id;
Roshan Pius8574e7f2019-04-01 13:30:40 -0700848 setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
Ahmed ElArabawy2134bf72020-06-18 15:07:12 -0700849
850 legacy_hal_.lock()->registerSubsystemRestartCallbackHandler(
851 subsystemCallbackHandler_);
852
Roshan Pius2c06a3f2016-12-15 17:51:40 -0800853 return status;
Roshan Pius3c868522016-10-27 12:43:49 -0700854}
855
856std::pair<WifiStatus, uint32_t> WifiChip::getModeInternal() {
Roshan Piuscc338202017-11-02 13:54:09 -0700857 if (!isValidModeId(current_mode_id_)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700858 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE),
859 current_mode_id_};
860 }
861 return {createWifiStatus(WifiStatusCode::SUCCESS), current_mode_id_};
Roshan Pius3c868522016-10-27 12:43:49 -0700862}
863
Jimmy Chend460df32019-11-29 17:31:22 +0200864std::pair<WifiStatus, V1_4::IWifiChip::ChipDebugInfo>
Roshan Pius3c868522016-10-27 12:43:49 -0700865WifiChip::requestChipDebugInfoInternal() {
Jimmy Chend460df32019-11-29 17:31:22 +0200866 V1_4::IWifiChip::ChipDebugInfo result;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700867 legacy_hal::wifi_error legacy_status;
868 std::string driver_desc;
Roshan Pius6036c022019-03-27 10:41:58 -0700869 const auto ifname = getFirstActiveWlanIfaceName();
Roshan Piusabcf78f2017-10-06 16:30:38 -0700870 std::tie(legacy_status, driver_desc) =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800871 legacy_hal_.lock()->getDriverVersion(ifname);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700872 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
873 LOG(ERROR) << "Failed to get driver version: "
874 << legacyErrorToString(legacy_status);
875 WifiStatus status = createWifiStatusFromLegacyError(
876 legacy_status, "failed to get driver version");
877 return {status, result};
878 }
879 result.driverDescription = driver_desc.c_str();
Roshan Pius3c868522016-10-27 12:43:49 -0700880
Roshan Piusabcf78f2017-10-06 16:30:38 -0700881 std::string firmware_desc;
882 std::tie(legacy_status, firmware_desc) =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800883 legacy_hal_.lock()->getFirmwareVersion(ifname);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700884 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
885 LOG(ERROR) << "Failed to get firmware version: "
886 << legacyErrorToString(legacy_status);
887 WifiStatus status = createWifiStatusFromLegacyError(
888 legacy_status, "failed to get firmware version");
889 return {status, result};
890 }
891 result.firmwareDescription = firmware_desc.c_str();
Roshan Pius3c868522016-10-27 12:43:49 -0700892
Roshan Piusabcf78f2017-10-06 16:30:38 -0700893 return {createWifiStatus(WifiStatusCode::SUCCESS), result};
Roshan Pius3c868522016-10-27 12:43:49 -0700894}
895
896std::pair<WifiStatus, std::vector<uint8_t>>
897WifiChip::requestDriverDebugDumpInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700898 legacy_hal::wifi_error legacy_status;
899 std::vector<uint8_t> driver_dump;
900 std::tie(legacy_status, driver_dump) =
Roshan Pius6036c022019-03-27 10:41:58 -0700901 legacy_hal_.lock()->requestDriverMemoryDump(
902 getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -0700903 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
904 LOG(ERROR) << "Failed to get driver debug dump: "
905 << legacyErrorToString(legacy_status);
906 return {createWifiStatusFromLegacyError(legacy_status),
907 std::vector<uint8_t>()};
908 }
909 return {createWifiStatus(WifiStatusCode::SUCCESS), driver_dump};
Roshan Pius3c868522016-10-27 12:43:49 -0700910}
911
912std::pair<WifiStatus, std::vector<uint8_t>>
913WifiChip::requestFirmwareDebugDumpInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700914 legacy_hal::wifi_error legacy_status;
915 std::vector<uint8_t> firmware_dump;
916 std::tie(legacy_status, firmware_dump) =
Roshan Pius6036c022019-03-27 10:41:58 -0700917 legacy_hal_.lock()->requestFirmwareMemoryDump(
918 getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -0700919 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
920 LOG(ERROR) << "Failed to get firmware debug dump: "
921 << legacyErrorToString(legacy_status);
922 return {createWifiStatusFromLegacyError(legacy_status), {}};
923 }
924 return {createWifiStatus(WifiStatusCode::SUCCESS), firmware_dump};
Roshan Pius3c868522016-10-27 12:43:49 -0700925}
926
lesl94d28242020-11-18 22:17:37 +0800927WifiStatus WifiChip::createVirtualApInterface(const std::string& apVirtIf) {
928 legacy_hal::wifi_error legacy_status;
929 legacy_status = legacy_hal_.lock()->createVirtualInterface(
930 apVirtIf,
931 hidl_struct_util::convertHidlIfaceTypeToLegacy(IfaceType::AP));
Sunil Raviddab4bb2020-02-03 22:45:19 -0800932 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
lesl94d28242020-11-18 22:17:37 +0800933 LOG(ERROR) << "Failed to add interface: " << apVirtIf << " "
Sunil Raviddab4bb2020-02-03 22:45:19 -0800934 << legacyErrorToString(legacy_status);
lesl94d28242020-11-18 22:17:37 +0800935 return createWifiStatusFromLegacyError(legacy_status);
Sunil Raviddab4bb2020-02-03 22:45:19 -0800936 }
lesl94d28242020-11-18 22:17:37 +0800937 return createWifiStatus(WifiStatusCode::SUCCESS);
938}
939
940sp<WifiApIface> WifiChip::newWifiApIface(std::string& ifname) {
lesl420c4fc2020-11-23 19:33:04 +0800941 std::vector<std::string> ap_instances;
942 for (auto const& it : br_ifaces_ap_instances_) {
943 if (it.first == ifname) {
944 ap_instances = it.second;
945 }
946 }
947 sp<WifiApIface> iface =
948 new WifiApIface(ifname, ap_instances, legacy_hal_, iface_util_);
Roshan Pius675609b2017-10-31 14:24:58 -0700949 ap_ifaces_.push_back(iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700950 for (const auto& callback : event_cb_handler_.getCallbacks()) {
951 if (!callback->onIfaceAdded(IfaceType::AP, ifname).isOk()) {
952 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
953 }
954 }
Roshan Pius8574e7f2019-04-01 13:30:40 -0700955 setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
lesl94d28242020-11-18 22:17:37 +0800956 return iface;
957}
958
lesl420c4fc2020-11-23 19:33:04 +0800959std::pair<WifiStatus, sp<V1_5::IWifiApIface>>
960WifiChip::createApIfaceInternal() {
lesl94d28242020-11-18 22:17:37 +0800961 if (!canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType::AP)) {
962 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
963 }
964 std::string ifname = allocateApIfaceName();
965 WifiStatus status = createVirtualApInterface(ifname);
966 if (status.code != WifiStatusCode::SUCCESS) {
967 return {status, {}};
968 }
969 sp<WifiApIface> iface = newWifiApIface(ifname);
970 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
971}
972
lesl420c4fc2020-11-23 19:33:04 +0800973std::pair<WifiStatus, sp<V1_5::IWifiApIface>>
lesl94d28242020-11-18 22:17:37 +0800974WifiChip::createBridgedApIfaceInternal() {
975 if (!canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType::AP)) {
976 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
977 }
lesl261818b2020-11-27 12:37:35 +0800978 std::vector<std::string> ap_instances = allocateBridgedApInstanceNames();
979 if (ap_instances.size() < 2) {
980 LOG(ERROR) << "Fail to allocate two instances";
981 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
982 }
983 std::string br_ifname = kApBridgeIfacePrefix + ap_instances[0];
lesl94d28242020-11-18 22:17:37 +0800984 for (int i = 0; i < 2; i++) {
lesl261818b2020-11-27 12:37:35 +0800985 WifiStatus status = createVirtualApInterface(ap_instances[i]);
lesl94d28242020-11-18 22:17:37 +0800986 if (status.code != WifiStatusCode::SUCCESS) {
lesl261818b2020-11-27 12:37:35 +0800987 if (i != 0) { // The failure happened when creating second virtual
988 // iface.
lesl94d28242020-11-18 22:17:37 +0800989 legacy_hal_.lock()->deleteVirtualInterface(
lesl261818b2020-11-27 12:37:35 +0800990 ap_instances.front()); // Remove the first virtual iface.
lesl94d28242020-11-18 22:17:37 +0800991 }
992 return {status, {}};
993 }
lesl94d28242020-11-18 22:17:37 +0800994 }
995 br_ifaces_ap_instances_[br_ifname] = ap_instances;
Roshan Pius8c1a67b2021-03-02 10:00:23 -0800996 if (!iface_util_->createBridge(br_ifname)) {
lesl94d28242020-11-18 22:17:37 +0800997 LOG(ERROR) << "Failed createBridge - br_name=" << br_ifname.c_str();
998 invalidateAndClearBridgedAp(br_ifname);
999 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
1000 }
1001 for (auto const& instance : ap_instances) {
1002 // Bind ap instance interface to AP bridge
Roshan Pius8c1a67b2021-03-02 10:00:23 -08001003 if (!iface_util_->addIfaceToBridge(br_ifname, instance)) {
lesl94d28242020-11-18 22:17:37 +08001004 LOG(ERROR) << "Failed add if to Bridge - if_name="
1005 << instance.c_str();
1006 invalidateAndClearBridgedAp(br_ifname);
1007 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
1008 }
1009 }
1010 sp<WifiApIface> iface = newWifiApIface(br_ifname);
Roshan Pius675609b2017-10-31 14:24:58 -07001011 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -07001012}
1013
1014std::pair<WifiStatus, std::vector<hidl_string>>
1015WifiChip::getApIfaceNamesInternal() {
Roshan Pius675609b2017-10-31 14:24:58 -07001016 if (ap_ifaces_.empty()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001017 return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
1018 }
Roshan Pius675609b2017-10-31 14:24:58 -07001019 return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(ap_ifaces_)};
Roshan Pius3c868522016-10-27 12:43:49 -07001020}
1021
lesl420c4fc2020-11-23 19:33:04 +08001022std::pair<WifiStatus, sp<V1_5::IWifiApIface>> WifiChip::getApIfaceInternal(
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001023 const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -07001024 const auto iface = findUsingName(ap_ifaces_, ifname);
1025 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001026 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
1027 }
Roshan Pius675609b2017-10-31 14:24:58 -07001028 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -07001029}
1030
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001031WifiStatus WifiChip::removeApIfaceInternal(const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -07001032 const auto iface = findUsingName(ap_ifaces_, ifname);
1033 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001034 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
Roshan Piusbc662202017-01-30 17:07:42 -08001035 }
Roshan Pius82368502019-05-16 12:53:02 -07001036 // Invalidate & remove any dependent objects first.
1037 // Note: This is probably not required because we never create
1038 // nan/rtt objects over AP iface. But, there is no harm to do it
1039 // here and not make that assumption all over the place.
1040 invalidateAndRemoveDependencies(ifname);
lesl94d28242020-11-18 22:17:37 +08001041 // Clear the bridge interface and the iface instance.
1042 invalidateAndClearBridgedAp(ifname);
Roshan Pius675609b2017-10-31 14:24:58 -07001043 invalidateAndClear(ap_ifaces_, iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001044 for (const auto& callback : event_cb_handler_.getCallbacks()) {
1045 if (!callback->onIfaceRemoved(IfaceType::AP, ifname).isOk()) {
1046 LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
1047 }
1048 }
Roshan Pius8574e7f2019-04-01 13:30:40 -07001049 setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -07001050 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001051}
1052
lesl94d28242020-11-18 22:17:37 +08001053WifiStatus WifiChip::removeIfaceInstanceFromBridgedApIfaceInternal(
1054 const std::string& ifname, const std::string& ifInstanceName) {
lesl94d28242020-11-18 22:17:37 +08001055 const auto iface = findUsingName(ap_ifaces_, ifname);
lesl819e3722021-01-07 09:49:04 +08001056 if (!iface.get() || ifInstanceName.empty()) {
lesl94d28242020-11-18 22:17:37 +08001057 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
1058 }
1059 // Requires to remove one of the instance in bridge mode
1060 for (auto const& it : br_ifaces_ap_instances_) {
1061 if (it.first == ifname) {
Les Lee03d642f2021-06-21 21:25:20 +08001062 std::vector<std::string> ap_instances = it.second;
1063 for (auto const& iface : ap_instances) {
lesl94d28242020-11-18 22:17:37 +08001064 if (iface == ifInstanceName) {
Roshan Pius8c1a67b2021-03-02 10:00:23 -08001065 if (!iface_util_->removeIfaceFromBridge(it.first, iface)) {
George Burgess IV2c0a47d2021-01-20 21:14:13 -08001066 LOG(ERROR)
1067 << "Failed to remove interface: " << ifInstanceName
1068 << " from " << ifname;
lesl94d28242020-11-18 22:17:37 +08001069 return createWifiStatus(
1070 WifiStatusCode::ERROR_NOT_AVAILABLE);
1071 }
George Burgess IV2c0a47d2021-01-20 21:14:13 -08001072 legacy_hal::wifi_error legacy_status =
lesl94d28242020-11-18 22:17:37 +08001073 legacy_hal_.lock()->deleteVirtualInterface(iface);
1074 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1075 LOG(ERROR) << "Failed to del interface: " << iface
1076 << " " << legacyErrorToString(legacy_status);
1077 return createWifiStatusFromLegacyError(legacy_status);
1078 }
Les Lee03d642f2021-06-21 21:25:20 +08001079 ap_instances.erase(
1080 std::remove(ap_instances.begin(), ap_instances.end(),
1081 ifInstanceName),
1082 ap_instances.end());
1083 br_ifaces_ap_instances_[ifname] = ap_instances;
1084 break;
lesl94d28242020-11-18 22:17:37 +08001085 }
1086 }
1087 break;
1088 }
1089 }
lesl669c9062021-01-22 19:37:47 +08001090 iface->removeInstance(ifInstanceName);
Les Lee03d642f2021-06-21 21:25:20 +08001091 setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
1092
lesl94d28242020-11-18 22:17:37 +08001093 return createWifiStatus(WifiStatusCode::SUCCESS);
1094}
1095
Jimmy Chend460df32019-11-29 17:31:22 +02001096std::pair<WifiStatus, sp<V1_4::IWifiNanIface>>
1097WifiChip::createNanIfaceInternal() {
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001098 if (!canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType::NAN)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001099 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
Etan Cohenc5700402017-03-08 16:43:38 -08001100 }
Roshan Pius5ba0a902020-04-14 11:55:42 -07001101 bool is_dedicated_iface = true;
lesl261818b2020-11-27 12:37:35 +08001102 std::string ifname = getPredefinedNanIfaceName();
Roshan Pius8c1a67b2021-03-02 10:00:23 -08001103 if (ifname.empty() || !iface_util_->ifNameToIndex(ifname)) {
Roshan Pius5ba0a902020-04-14 11:55:42 -07001104 // Use the first shared STA iface (wlan0) if a dedicated aware iface is
1105 // not defined.
1106 ifname = getFirstActiveWlanIfaceName();
1107 is_dedicated_iface = false;
1108 }
1109 sp<WifiNanIface> iface =
1110 new WifiNanIface(ifname, is_dedicated_iface, legacy_hal_, iface_util_);
Roshan Piuscc338202017-11-02 13:54:09 -07001111 nan_ifaces_.push_back(iface);
1112 for (const auto& callback : event_cb_handler_.getCallbacks()) {
1113 if (!callback->onIfaceAdded(IfaceType::NAN, ifname).isOk()) {
1114 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
1115 }
1116 }
1117 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -07001118}
1119
1120std::pair<WifiStatus, std::vector<hidl_string>>
1121WifiChip::getNanIfaceNamesInternal() {
Roshan Pius675609b2017-10-31 14:24:58 -07001122 if (nan_ifaces_.empty()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001123 return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
1124 }
Roshan Pius675609b2017-10-31 14:24:58 -07001125 return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(nan_ifaces_)};
Roshan Pius3c868522016-10-27 12:43:49 -07001126}
1127
Jimmy Chend460df32019-11-29 17:31:22 +02001128std::pair<WifiStatus, sp<V1_4::IWifiNanIface>> WifiChip::getNanIfaceInternal(
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001129 const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -07001130 const auto iface = findUsingName(nan_ifaces_, ifname);
1131 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001132 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
1133 }
Roshan Pius675609b2017-10-31 14:24:58 -07001134 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -07001135}
1136
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001137WifiStatus WifiChip::removeNanIfaceInternal(const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -07001138 const auto iface = findUsingName(nan_ifaces_, ifname);
1139 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001140 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
Roshan Piusbc662202017-01-30 17:07:42 -08001141 }
Roshan Pius675609b2017-10-31 14:24:58 -07001142 invalidateAndClear(nan_ifaces_, iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001143 for (const auto& callback : event_cb_handler_.getCallbacks()) {
1144 if (!callback->onIfaceRemoved(IfaceType::NAN, ifname).isOk()) {
1145 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
1146 }
1147 }
1148 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001149}
1150
Roshan Pius3c868522016-10-27 12:43:49 -07001151std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::createP2pIfaceInternal() {
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001152 if (!canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType::P2P)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001153 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
Roshan Piusbc662202017-01-30 17:07:42 -08001154 }
lesl261818b2020-11-27 12:37:35 +08001155 std::string ifname = getPredefinedP2pIfaceName();
Roshan Pius675609b2017-10-31 14:24:58 -07001156 sp<WifiP2pIface> iface = new WifiP2pIface(ifname, legacy_hal_);
1157 p2p_ifaces_.push_back(iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001158 for (const auto& callback : event_cb_handler_.getCallbacks()) {
1159 if (!callback->onIfaceAdded(IfaceType::P2P, ifname).isOk()) {
1160 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
1161 }
1162 }
Roshan Pius675609b2017-10-31 14:24:58 -07001163 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -07001164}
1165
1166std::pair<WifiStatus, std::vector<hidl_string>>
1167WifiChip::getP2pIfaceNamesInternal() {
Roshan Pius675609b2017-10-31 14:24:58 -07001168 if (p2p_ifaces_.empty()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001169 return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
1170 }
Roshan Pius675609b2017-10-31 14:24:58 -07001171 return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(p2p_ifaces_)};
Roshan Pius3c868522016-10-27 12:43:49 -07001172}
1173
1174std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::getP2pIfaceInternal(
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001175 const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -07001176 const auto iface = findUsingName(p2p_ifaces_, ifname);
1177 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001178 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
1179 }
Roshan Pius675609b2017-10-31 14:24:58 -07001180 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -07001181}
1182
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001183WifiStatus WifiChip::removeP2pIfaceInternal(const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -07001184 const auto iface = findUsingName(p2p_ifaces_, ifname);
1185 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001186 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
Roshan Piusbc662202017-01-30 17:07:42 -08001187 }
Roshan Pius675609b2017-10-31 14:24:58 -07001188 invalidateAndClear(p2p_ifaces_, iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001189 for (const auto& callback : event_cb_handler_.getCallbacks()) {
1190 if (!callback->onIfaceRemoved(IfaceType::P2P, ifname).isOk()) {
1191 LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
1192 }
1193 }
1194 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001195}
1196
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001197std::pair<WifiStatus, sp<V1_5::IWifiStaIface>>
Ahmed ElArabawyb23485d2019-12-09 15:24:16 -08001198WifiChip::createStaIfaceInternal() {
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001199 if (!canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType::STA)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001200 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
Roshan Piusbc662202017-01-30 17:07:42 -08001201 }
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001202 std::string ifname = allocateStaIfaceName();
Sunil Raviddab4bb2020-02-03 22:45:19 -08001203 legacy_hal::wifi_error legacy_status =
1204 legacy_hal_.lock()->createVirtualInterface(
1205 ifname,
1206 hidl_struct_util::convertHidlIfaceTypeToLegacy(IfaceType::STA));
1207 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1208 LOG(ERROR) << "Failed to add interface: " << ifname << " "
1209 << legacyErrorToString(legacy_status);
1210 return {createWifiStatusFromLegacyError(legacy_status), {}};
1211 }
Roshan Pius99dab382019-02-14 07:57:10 -08001212 sp<WifiStaIface> iface = new WifiStaIface(ifname, legacy_hal_, iface_util_);
Roshan Pius675609b2017-10-31 14:24:58 -07001213 sta_ifaces_.push_back(iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001214 for (const auto& callback : event_cb_handler_.getCallbacks()) {
1215 if (!callback->onIfaceAdded(IfaceType::STA, ifname).isOk()) {
1216 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
1217 }
1218 }
Roshan Pius8574e7f2019-04-01 13:30:40 -07001219 setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
Roshan Pius675609b2017-10-31 14:24:58 -07001220 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -07001221}
1222
1223std::pair<WifiStatus, std::vector<hidl_string>>
1224WifiChip::getStaIfaceNamesInternal() {
Roshan Pius675609b2017-10-31 14:24:58 -07001225 if (sta_ifaces_.empty()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001226 return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
1227 }
Roshan Pius675609b2017-10-31 14:24:58 -07001228 return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(sta_ifaces_)};
Roshan Pius3c868522016-10-27 12:43:49 -07001229}
1230
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001231std::pair<WifiStatus, sp<V1_5::IWifiStaIface>> WifiChip::getStaIfaceInternal(
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001232 const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -07001233 const auto iface = findUsingName(sta_ifaces_, ifname);
1234 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001235 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
1236 }
Roshan Pius675609b2017-10-31 14:24:58 -07001237 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -07001238}
1239
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001240WifiStatus WifiChip::removeStaIfaceInternal(const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -07001241 const auto iface = findUsingName(sta_ifaces_, ifname);
1242 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001243 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
Roshan Piusbc662202017-01-30 17:07:42 -08001244 }
Roshan Pius82368502019-05-16 12:53:02 -07001245 // Invalidate & remove any dependent objects first.
1246 invalidateAndRemoveDependencies(ifname);
Sunil Raviddab4bb2020-02-03 22:45:19 -08001247 legacy_hal::wifi_error legacy_status =
1248 legacy_hal_.lock()->deleteVirtualInterface(ifname);
1249 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1250 LOG(ERROR) << "Failed to remove interface: " << ifname << " "
1251 << legacyErrorToString(legacy_status);
1252 }
Roshan Pius675609b2017-10-31 14:24:58 -07001253 invalidateAndClear(sta_ifaces_, iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001254 for (const auto& callback : event_cb_handler_.getCallbacks()) {
1255 if (!callback->onIfaceRemoved(IfaceType::STA, ifname).isOk()) {
1256 LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
1257 }
1258 }
Roshan Pius8574e7f2019-04-01 13:30:40 -07001259 setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -07001260 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001261}
1262
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07001263std::pair<WifiStatus, sp<V1_0::IWifiRttController>>
1264WifiChip::createRttControllerInternal(const sp<IWifiIface>& /*bound_iface*/) {
1265 LOG(ERROR) << "createRttController is not supported on this HAL";
Ahmed ElArabawy36defb32019-12-29 21:24:27 -08001266 return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
Roshan Pius3c868522016-10-27 12:43:49 -07001267}
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001268
1269std::pair<WifiStatus, std::vector<WifiDebugRingBufferStatus>>
1270WifiChip::getDebugRingBuffersStatusInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001271 legacy_hal::wifi_error legacy_status;
1272 std::vector<legacy_hal::wifi_ring_buffer_status>
1273 legacy_ring_buffer_status_vec;
1274 std::tie(legacy_status, legacy_ring_buffer_status_vec) =
Roshan Pius6036c022019-03-27 10:41:58 -07001275 legacy_hal_.lock()->getRingBuffersStatus(getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -07001276 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1277 return {createWifiStatusFromLegacyError(legacy_status), {}};
1278 }
1279 std::vector<WifiDebugRingBufferStatus> hidl_ring_buffer_status_vec;
1280 if (!hidl_struct_util::convertLegacyVectorOfDebugRingBufferStatusToHidl(
1281 legacy_ring_buffer_status_vec, &hidl_ring_buffer_status_vec)) {
1282 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
1283 }
1284 return {createWifiStatus(WifiStatusCode::SUCCESS),
1285 hidl_ring_buffer_status_vec};
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001286}
1287
1288WifiStatus WifiChip::startLoggingToDebugRingBufferInternal(
Roshan Piusabcf78f2017-10-06 16:30:38 -07001289 const hidl_string& ring_name, WifiDebugRingBufferVerboseLevel verbose_level,
1290 uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes) {
1291 WifiStatus status = registerDebugRingBufferCallback();
1292 if (status.code != WifiStatusCode::SUCCESS) {
1293 return status;
1294 }
1295 legacy_hal::wifi_error legacy_status =
1296 legacy_hal_.lock()->startRingBufferLogging(
Roshan Pius6036c022019-03-27 10:41:58 -07001297 getFirstActiveWlanIfaceName(), ring_name,
Roshan Piusabcf78f2017-10-06 16:30:38 -07001298 static_cast<
1299 std::underlying_type<WifiDebugRingBufferVerboseLevel>::type>(
1300 verbose_level),
1301 max_interval_in_sec, min_data_size_in_bytes);
xshu5899e8e2018-01-09 15:36:03 -08001302 ringbuffer_map_.insert(std::pair<std::string, Ringbuffer>(
1303 ring_name, Ringbuffer(kMaxBufferSizeBytes)));
Roshan Piusa63b53f2019-11-18 11:03:13 -08001304 // if verbose logging enabled, turn up HAL daemon logging as well.
1305 if (verbose_level < WifiDebugRingBufferVerboseLevel::VERBOSE) {
1306 android::base::SetMinimumLogSeverity(android::base::DEBUG);
1307 } else {
1308 android::base::SetMinimumLogSeverity(android::base::VERBOSE);
1309 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001310 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001311}
1312
1313WifiStatus WifiChip::forceDumpToDebugRingBufferInternal(
Roshan Piuse2d0ab52016-12-05 15:24:20 -08001314 const hidl_string& ring_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001315 WifiStatus status = registerDebugRingBufferCallback();
1316 if (status.code != WifiStatusCode::SUCCESS) {
1317 return status;
1318 }
1319 legacy_hal::wifi_error legacy_status =
Roshan Pius6036c022019-03-27 10:41:58 -07001320 legacy_hal_.lock()->getRingBufferData(getFirstActiveWlanIfaceName(),
1321 ring_name);
xshu5899e8e2018-01-09 15:36:03 -08001322
Roshan Piusabcf78f2017-10-06 16:30:38 -07001323 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001324}
1325
Roger Wangb294c762018-11-02 15:34:39 +08001326WifiStatus WifiChip::flushRingBufferToFileInternal() {
1327 if (!writeRingbufferFilesInternal()) {
1328 LOG(ERROR) << "Error writing files to flash";
1329 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
1330 }
1331 return createWifiStatus(WifiStatusCode::SUCCESS);
1332}
1333
Roshan Pius8c0c8e92017-02-24 08:07:42 -08001334WifiStatus WifiChip::stopLoggingToDebugRingBufferInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001335 legacy_hal::wifi_error legacy_status =
1336 legacy_hal_.lock()->deregisterRingBufferCallbackHandler(
Roshan Pius6036c022019-03-27 10:41:58 -07001337 getFirstActiveWlanIfaceName());
xshu0a0fe512020-07-22 17:53:37 -07001338 if (legacy_status == legacy_hal::WIFI_SUCCESS) {
1339 debug_ring_buffer_cb_registered_ = false;
1340 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001341 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius8c0c8e92017-02-24 08:07:42 -08001342}
1343
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001344std::pair<WifiStatus, WifiDebugHostWakeReasonStats>
1345WifiChip::getDebugHostWakeReasonStatsInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001346 legacy_hal::wifi_error legacy_status;
1347 legacy_hal::WakeReasonStats legacy_stats;
1348 std::tie(legacy_status, legacy_stats) =
Roshan Pius6036c022019-03-27 10:41:58 -07001349 legacy_hal_.lock()->getWakeReasonStats(getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -07001350 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1351 return {createWifiStatusFromLegacyError(legacy_status), {}};
1352 }
1353 WifiDebugHostWakeReasonStats hidl_stats;
1354 if (!hidl_struct_util::convertLegacyWakeReasonStatsToHidl(legacy_stats,
1355 &hidl_stats)) {
1356 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
1357 }
1358 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_stats};
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001359}
1360
Roshan Pius203cb032016-12-14 17:41:20 -08001361WifiStatus WifiChip::enableDebugErrorAlertsInternal(bool enable) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001362 legacy_hal::wifi_error legacy_status;
1363 if (enable) {
1364 android::wp<WifiChip> weak_ptr_this(this);
1365 const auto& on_alert_callback = [weak_ptr_this](
1366 int32_t error_code,
1367 std::vector<uint8_t> debug_data) {
1368 const auto shared_ptr_this = weak_ptr_this.promote();
1369 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
1370 LOG(ERROR) << "Callback invoked on an invalid object";
1371 return;
1372 }
1373 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
1374 if (!callback->onDebugErrorAlert(error_code, debug_data)
1375 .isOk()) {
1376 LOG(ERROR) << "Failed to invoke onDebugErrorAlert callback";
1377 }
1378 }
1379 };
1380 legacy_status = legacy_hal_.lock()->registerErrorAlertCallbackHandler(
Roshan Pius6036c022019-03-27 10:41:58 -07001381 getFirstActiveWlanIfaceName(), on_alert_callback);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001382 } else {
1383 legacy_status = legacy_hal_.lock()->deregisterErrorAlertCallbackHandler(
Roshan Pius6036c022019-03-27 10:41:58 -07001384 getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -07001385 }
1386 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius203cb032016-12-14 17:41:20 -08001387}
Roshan Pius2c06a3f2016-12-15 17:51:40 -08001388
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -08001389WifiStatus WifiChip::selectTxPowerScenarioInternal(
Jong Wook Kimda830c92018-07-23 15:29:38 -07001390 V1_1::IWifiChip::TxPowerScenario scenario) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001391 auto legacy_status = legacy_hal_.lock()->selectTxPowerScenario(
Roshan Pius6036c022019-03-27 10:41:58 -07001392 getFirstActiveWlanIfaceName(),
Roshan Piusabcf78f2017-10-06 16:30:38 -07001393 hidl_struct_util::convertHidlTxPowerScenarioToLegacy(scenario));
1394 return createWifiStatusFromLegacyError(legacy_status);
Roshan Piusdbd83ef2017-06-20 12:05:40 -07001395}
1396
Roshan Pius735ff432017-07-25 08:48:08 -07001397WifiStatus WifiChip::resetTxPowerScenarioInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001398 auto legacy_status =
Roshan Pius6036c022019-03-27 10:41:58 -07001399 legacy_hal_.lock()->resetTxPowerScenario(getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -07001400 return createWifiStatusFromLegacyError(legacy_status);
Roshan Piusdbd83ef2017-06-20 12:05:40 -07001401}
1402
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -07001403WifiStatus WifiChip::setLatencyModeInternal(LatencyMode mode) {
1404 auto legacy_status = legacy_hal_.lock()->setLatencyMode(
Roshan Pius6036c022019-03-27 10:41:58 -07001405 getFirstActiveWlanIfaceName(),
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -07001406 hidl_struct_util::convertHidlLatencyModeToLegacy(mode));
1407 return createWifiStatusFromLegacyError(legacy_status);
1408}
1409
Roshan Pius1ce92cf2018-01-22 16:12:19 -08001410WifiStatus WifiChip::registerEventCallbackInternal_1_2(
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -08001411 const sp<V1_2::IWifiChipEventCallback>& /* event_callback */) {
1412 // Deprecated support for this callback.
1413 return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
Roshan Pius1ce92cf2018-01-22 16:12:19 -08001414}
1415
Jong Wook Kimda830c92018-07-23 15:29:38 -07001416WifiStatus WifiChip::selectTxPowerScenarioInternal_1_2(
1417 TxPowerScenario scenario) {
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -08001418 auto legacy_status = legacy_hal_.lock()->selectTxPowerScenario(
Roshan Pius6036c022019-03-27 10:41:58 -07001419 getFirstActiveWlanIfaceName(),
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -08001420 hidl_struct_util::convertHidlTxPowerScenarioToLegacy_1_2(scenario));
1421 return createWifiStatusFromLegacyError(legacy_status);
1422}
1423
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07001424std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal_1_3() {
Jimmy Chen1bdf1a72019-12-23 17:53:40 +02001425 // Deprecated support for this callback.
1426 return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), 0};
1427}
1428
1429std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal_1_5() {
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07001430 legacy_hal::wifi_error legacy_status;
Jimmy Chen1bdf1a72019-12-23 17:53:40 +02001431 uint64_t legacy_feature_set;
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07001432 uint32_t legacy_logger_feature_set;
1433 const auto ifname = getFirstActiveWlanIfaceName();
1434 std::tie(legacy_status, legacy_feature_set) =
1435 legacy_hal_.lock()->getSupportedFeatureSet(ifname);
1436 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1437 return {createWifiStatusFromLegacyError(legacy_status), 0};
1438 }
1439 std::tie(legacy_status, legacy_logger_feature_set) =
1440 legacy_hal_.lock()->getLoggerSupportedFeatureSet(ifname);
1441 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1442 // some devices don't support querying logger feature set
1443 legacy_logger_feature_set = 0;
1444 }
1445 uint32_t hidl_caps;
1446 if (!hidl_struct_util::convertLegacyFeaturesToHidlChipCapabilities(
1447 legacy_feature_set, legacy_logger_feature_set, &hidl_caps)) {
1448 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), 0};
1449 }
1450 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
1451}
1452
Jimmy Chend460df32019-11-29 17:31:22 +02001453std::pair<WifiStatus, sp<V1_4::IWifiRttController>>
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07001454WifiChip::createRttControllerInternal_1_4(const sp<IWifiIface>& bound_iface) {
1455 if (sta_ifaces_.size() == 0 &&
1456 !canCurrentModeSupportIfaceOfType(IfaceType::STA)) {
1457 LOG(ERROR)
1458 << "createRttControllerInternal_1_4: Chip cannot support STAs "
1459 "(and RTT by extension)";
1460 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
1461 }
1462 sp<WifiRttController> rtt = new WifiRttController(
1463 getFirstActiveWlanIfaceName(), bound_iface, legacy_hal_);
1464 rtt_controllers_.emplace_back(rtt);
1465 return {createWifiStatus(WifiStatusCode::SUCCESS), rtt};
1466}
1467
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -08001468WifiStatus WifiChip::registerEventCallbackInternal_1_4(
Jimmy Chend460df32019-11-29 17:31:22 +02001469 const sp<V1_4::IWifiChipEventCallback>& event_callback) {
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -08001470 if (!event_cb_handler_.addCallback(event_callback)) {
1471 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
1472 }
1473 return createWifiStatus(WifiStatusCode::SUCCESS);
1474}
1475
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001476WifiStatus WifiChip::setMultiStaPrimaryConnectionInternal(
1477 const std::string& ifname) {
1478 auto legacy_status =
1479 legacy_hal_.lock()->multiStaSetPrimaryConnection(ifname);
1480 return createWifiStatusFromLegacyError(legacy_status);
1481}
1482
1483WifiStatus WifiChip::setMultiStaUseCaseInternal(MultiStaUseCase use_case) {
1484 auto legacy_status = legacy_hal_.lock()->multiStaSetUseCase(
1485 hidl_struct_util::convertHidlMultiStaUseCaseToLegacy(use_case));
1486 return createWifiStatusFromLegacyError(legacy_status);
1487}
1488
Quang Luong94bcce52020-11-25 17:52:19 -08001489WifiStatus WifiChip::setCoexUnsafeChannelsInternal(
1490 std::vector<CoexUnsafeChannel> unsafe_channels, uint32_t restrictions) {
1491 std::vector<legacy_hal::wifi_coex_unsafe_channel> legacy_unsafe_channels;
1492 if (!hidl_struct_util::convertHidlVectorOfCoexUnsafeChannelToLegacy(
1493 unsafe_channels, &legacy_unsafe_channels)) {
1494 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
1495 }
Quang Luongab70a832020-12-14 13:01:32 -08001496 uint32_t legacy_restrictions = 0;
1497 if (restrictions & CoexRestriction::WIFI_DIRECT) {
1498 legacy_restrictions |= legacy_hal::wifi_coex_restriction::WIFI_DIRECT;
1499 }
1500 if (restrictions & CoexRestriction::SOFTAP) {
1501 legacy_restrictions |= legacy_hal::wifi_coex_restriction::SOFTAP;
1502 }
1503 if (restrictions & CoexRestriction::WIFI_AWARE) {
1504 legacy_restrictions |= legacy_hal::wifi_coex_restriction::WIFI_AWARE;
1505 }
Quang Luong94bcce52020-11-25 17:52:19 -08001506 auto legacy_status = legacy_hal_.lock()->setCoexUnsafeChannels(
Quang Luongab70a832020-12-14 13:01:32 -08001507 legacy_unsafe_channels, legacy_restrictions);
Quang Luong94bcce52020-11-25 17:52:19 -08001508 return createWifiStatusFromLegacyError(legacy_status);
1509}
1510
Kumar Anandda62c382020-11-18 17:17:47 -08001511WifiStatus WifiChip::setCountryCodeInternal(const std::array<int8_t, 2>& code) {
1512 auto legacy_status =
1513 legacy_hal_.lock()->setCountryCode(getFirstActiveWlanIfaceName(), code);
1514 return createWifiStatusFromLegacyError(legacy_status);
1515}
1516
Kumar Anand2a630a32021-01-21 14:09:14 -08001517std::pair<WifiStatus, std::vector<WifiUsableChannel>>
Kumar Anandaea86e02021-02-10 16:22:31 -08001518WifiChip::getUsableChannelsInternal(WifiBand band, uint32_t ifaceModeMask,
1519 uint32_t filterMask) {
Kumar Anand2a630a32021-01-21 14:09:14 -08001520 legacy_hal::wifi_error legacy_status;
1521 std::vector<legacy_hal::wifi_usable_channel> legacy_usable_channels;
1522 std::tie(legacy_status, legacy_usable_channels) =
1523 legacy_hal_.lock()->getUsableChannels(
1524 hidl_struct_util::convertHidlWifiBandToLegacyMacBand(band),
Kumar Anandaea86e02021-02-10 16:22:31 -08001525 hidl_struct_util::convertHidlWifiIfaceModeToLegacy(ifaceModeMask),
1526 hidl_struct_util::convertHidlUsableChannelFilterToLegacy(
1527 filterMask));
1528
Kumar Anand2a630a32021-01-21 14:09:14 -08001529 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1530 return {createWifiStatusFromLegacyError(legacy_status), {}};
1531 }
1532 std::vector<WifiUsableChannel> hidl_usable_channels;
1533 if (!hidl_struct_util::convertLegacyWifiUsableChannelsToHidl(
1534 legacy_usable_channels, &hidl_usable_channels)) {
1535 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
1536 }
1537 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_usable_channels};
1538}
1539
chenpaulc6f57032021-03-05 17:06:50 +08001540WifiStatus WifiChip::triggerSubsystemRestartInternal() {
1541 auto legacy_status = legacy_hal_.lock()->triggerSubsystemRestart();
1542 return createWifiStatusFromLegacyError(legacy_status);
1543}
1544
Roshan Piusba38d9c2017-12-08 07:32:08 -08001545WifiStatus WifiChip::handleChipConfiguration(
1546 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock,
1547 ChipModeId mode_id) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001548 // If the chip is already configured in a different mode, stop
1549 // the legacy HAL and then start it after firmware mode change.
Roshan Piuscc338202017-11-02 13:54:09 -07001550 if (isValidModeId(current_mode_id_)) {
Roshan Piusba38d9c2017-12-08 07:32:08 -08001551 LOG(INFO) << "Reconfiguring chip from mode " << current_mode_id_
1552 << " to mode " << mode_id;
1553 invalidateAndRemoveAllIfaces();
1554 legacy_hal::wifi_error legacy_status =
1555 legacy_hal_.lock()->stop(lock, []() {});
1556 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1557 LOG(ERROR) << "Failed to stop legacy HAL: "
1558 << legacyErrorToString(legacy_status);
1559 return createWifiStatusFromLegacyError(legacy_status);
1560 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001561 }
Roshan Piuscc338202017-11-02 13:54:09 -07001562 // Firmware mode change not needed for V2 devices.
1563 bool success = true;
Tomasz Wasilczykb424da72018-11-15 11:52:57 -08001564 if (mode_id == feature_flags::chip_mode_ids::kV1Sta) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001565 success = mode_controller_.lock()->changeFirmwareMode(IfaceType::STA);
Tomasz Wasilczykb424da72018-11-15 11:52:57 -08001566 } else if (mode_id == feature_flags::chip_mode_ids::kV1Ap) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001567 success = mode_controller_.lock()->changeFirmwareMode(IfaceType::AP);
1568 }
1569 if (!success) {
1570 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
1571 }
1572 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->start();
1573 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1574 LOG(ERROR) << "Failed to start legacy HAL: "
1575 << legacyErrorToString(legacy_status);
1576 return createWifiStatusFromLegacyError(legacy_status);
1577 }
Roshan Pius85c64412018-01-22 17:58:40 -08001578 // Every time the HAL is restarted, we need to register the
1579 // radio mode change callback.
1580 WifiStatus status = registerRadioModeChangeCallback();
1581 if (status.code != WifiStatusCode::SUCCESS) {
1582 // This probably is not a critical failure?
1583 LOG(ERROR) << "Failed to register radio mode change callback";
1584 }
chenpaulf5eca292019-03-14 11:08:03 +08001585 // Extract and save the version information into property.
Jimmy Chend460df32019-11-29 17:31:22 +02001586 std::pair<WifiStatus, V1_4::IWifiChip::ChipDebugInfo> version_info;
chenpaulf5eca292019-03-14 11:08:03 +08001587 version_info = WifiChip::requestChipDebugInfoInternal();
1588 if (WifiStatusCode::SUCCESS == version_info.first.code) {
1589 property_set("vendor.wlan.firmware.version",
1590 version_info.second.firmwareDescription.c_str());
1591 property_set("vendor.wlan.driver.version",
1592 version_info.second.driverDescription.c_str());
1593 }
1594
Roshan Piusabcf78f2017-10-06 16:30:38 -07001595 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius2c06a3f2016-12-15 17:51:40 -08001596}
Roshan Pius48185b22016-12-15 19:10:30 -08001597
1598WifiStatus WifiChip::registerDebugRingBufferCallback() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001599 if (debug_ring_buffer_cb_registered_) {
1600 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius48185b22016-12-15 19:10:30 -08001601 }
Roshan Pius3797e182017-03-30 18:01:54 -07001602
Roshan Piusabcf78f2017-10-06 16:30:38 -07001603 android::wp<WifiChip> weak_ptr_this(this);
1604 const auto& on_ring_buffer_data_callback =
xshu5899e8e2018-01-09 15:36:03 -08001605 [weak_ptr_this](const std::string& name,
Roshan Piusabcf78f2017-10-06 16:30:38 -07001606 const std::vector<uint8_t>& data,
1607 const legacy_hal::wifi_ring_buffer_status& status) {
1608 const auto shared_ptr_this = weak_ptr_this.promote();
1609 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
1610 LOG(ERROR) << "Callback invoked on an invalid object";
1611 return;
1612 }
1613 WifiDebugRingBufferStatus hidl_status;
1614 if (!hidl_struct_util::convertLegacyDebugRingBufferStatusToHidl(
1615 status, &hidl_status)) {
1616 LOG(ERROR) << "Error converting ring buffer status";
1617 return;
1618 }
Veerendranath Jakkam25b3a6f2020-04-14 22:04:39 +05301619 {
1620 std::unique_lock<std::mutex> lk(shared_ptr_this->lock_t);
1621 const auto& target =
1622 shared_ptr_this->ringbuffer_map_.find(name);
1623 if (target != shared_ptr_this->ringbuffer_map_.end()) {
1624 Ringbuffer& cur_buffer = target->second;
1625 cur_buffer.append(data);
1626 } else {
1627 LOG(ERROR) << "Ringname " << name << " not found";
1628 return;
1629 }
xshu0a0fe512020-07-22 17:53:37 -07001630 // unique_lock unlocked here
Roshan Piusabcf78f2017-10-06 16:30:38 -07001631 }
1632 };
1633 legacy_hal::wifi_error legacy_status =
1634 legacy_hal_.lock()->registerRingBufferCallbackHandler(
Roshan Pius6036c022019-03-27 10:41:58 -07001635 getFirstActiveWlanIfaceName(), on_ring_buffer_data_callback);
Roshan Pius48185b22016-12-15 19:10:30 -08001636
Roshan Piusabcf78f2017-10-06 16:30:38 -07001637 if (legacy_status == legacy_hal::WIFI_SUCCESS) {
1638 debug_ring_buffer_cb_registered_ = true;
1639 }
1640 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius48185b22016-12-15 19:10:30 -08001641}
1642
Roshan Pius85c64412018-01-22 17:58:40 -08001643WifiStatus WifiChip::registerRadioModeChangeCallback() {
1644 android::wp<WifiChip> weak_ptr_this(this);
1645 const auto& on_radio_mode_change_callback =
1646 [weak_ptr_this](const std::vector<legacy_hal::WifiMacInfo>& mac_infos) {
1647 const auto shared_ptr_this = weak_ptr_this.promote();
1648 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
1649 LOG(ERROR) << "Callback invoked on an invalid object";
1650 return;
1651 }
Jimmy Chend460df32019-11-29 17:31:22 +02001652 std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo>
Roshan Pius85c64412018-01-22 17:58:40 -08001653 hidl_radio_mode_infos;
1654 if (!hidl_struct_util::convertLegacyWifiMacInfosToHidl(
1655 mac_infos, &hidl_radio_mode_infos)) {
1656 LOG(ERROR) << "Error converting wifi mac info";
1657 return;
1658 }
1659 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -08001660 if (!callback->onRadioModeChange_1_4(hidl_radio_mode_infos)
Roshan Pius85c64412018-01-22 17:58:40 -08001661 .isOk()) {
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -08001662 LOG(ERROR) << "Failed to invoke onRadioModeChange_1_4"
Roshan Pius85c64412018-01-22 17:58:40 -08001663 << " callback on: " << toString(callback);
1664 }
1665 }
1666 };
1667 legacy_hal::wifi_error legacy_status =
1668 legacy_hal_.lock()->registerRadioModeChangeCallbackHandler(
Roshan Pius6036c022019-03-27 10:41:58 -07001669 getFirstActiveWlanIfaceName(), on_radio_mode_change_callback);
Roshan Pius85c64412018-01-22 17:58:40 -08001670 return createWifiStatusFromLegacyError(legacy_status);
1671}
1672
Jimmy Chend460df32019-11-29 17:31:22 +02001673std::vector<V1_4::IWifiChip::ChipIfaceCombination>
Roshan Piuscc338202017-11-02 13:54:09 -07001674WifiChip::getCurrentModeIfaceCombinations() {
1675 if (!isValidModeId(current_mode_id_)) {
1676 LOG(ERROR) << "Chip not configured in a mode yet";
1677 return {};
1678 }
1679 for (const auto& mode : modes_) {
1680 if (mode.id == current_mode_id_) {
1681 return mode.availableCombinations;
1682 }
1683 }
1684 CHECK(0) << "Expected to find iface combinations for current mode!";
1685 return {};
1686}
1687
1688// Returns a map indexed by IfaceType with the number of ifaces currently
1689// created of the corresponding type.
1690std::map<IfaceType, size_t> WifiChip::getCurrentIfaceCombination() {
1691 std::map<IfaceType, size_t> iface_counts;
1692 iface_counts[IfaceType::AP] = ap_ifaces_.size();
1693 iface_counts[IfaceType::NAN] = nan_ifaces_.size();
1694 iface_counts[IfaceType::P2P] = p2p_ifaces_.size();
1695 iface_counts[IfaceType::STA] = sta_ifaces_.size();
1696 return iface_counts;
1697}
1698
1699// This expands the provided iface combinations to a more parseable
1700// form. Returns a vector of available combinations possible with the number
1701// of ifaces of each type in the combination.
1702// This method is a port of HalDeviceManager.expandIfaceCombos() from framework.
1703std::vector<std::map<IfaceType, size_t>> WifiChip::expandIfaceCombinations(
Jimmy Chend460df32019-11-29 17:31:22 +02001704 const V1_4::IWifiChip::ChipIfaceCombination& combination) {
Roshan Piuscc338202017-11-02 13:54:09 -07001705 uint32_t num_expanded_combos = 1;
1706 for (const auto& limit : combination.limits) {
1707 for (uint32_t i = 0; i < limit.maxIfaces; i++) {
1708 num_expanded_combos *= limit.types.size();
1709 }
1710 }
1711
1712 // Allocate the vector of expanded combos and reset all iface counts to 0
1713 // in each combo.
1714 std::vector<std::map<IfaceType, size_t>> expanded_combos;
1715 expanded_combos.resize(num_expanded_combos);
1716 for (auto& expanded_combo : expanded_combos) {
1717 for (const auto type :
1718 {IfaceType::AP, IfaceType::NAN, IfaceType::P2P, IfaceType::STA}) {
1719 expanded_combo[type] = 0;
1720 }
1721 }
1722 uint32_t span = num_expanded_combos;
1723 for (const auto& limit : combination.limits) {
1724 for (uint32_t i = 0; i < limit.maxIfaces; i++) {
1725 span /= limit.types.size();
1726 for (uint32_t k = 0; k < num_expanded_combos; ++k) {
1727 const auto iface_type =
1728 limit.types[(k / span) % limit.types.size()];
1729 expanded_combos[k][iface_type]++;
1730 }
1731 }
1732 }
1733 return expanded_combos;
1734}
1735
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001736bool WifiChip::canExpandedIfaceComboSupportIfaceOfTypeWithCurrentIfaces(
1737 const std::map<IfaceType, size_t>& expanded_combo,
1738 IfaceType requested_type) {
Roshan Piuscc338202017-11-02 13:54:09 -07001739 const auto current_combo = getCurrentIfaceCombination();
1740
1741 // Check if we have space for 1 more iface of |type| in this combo
1742 for (const auto type :
1743 {IfaceType::AP, IfaceType::NAN, IfaceType::P2P, IfaceType::STA}) {
1744 size_t num_ifaces_needed = current_combo.at(type);
1745 if (type == requested_type) {
1746 num_ifaces_needed++;
1747 }
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001748 size_t num_ifaces_allowed = expanded_combo.at(type);
Roshan Piuscc338202017-11-02 13:54:09 -07001749 if (num_ifaces_needed > num_ifaces_allowed) {
1750 return false;
1751 }
1752 }
1753 return true;
1754}
1755
1756// This method does the following:
1757// a) Enumerate all possible iface combos by expanding the current
1758// ChipIfaceCombination.
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001759// b) Check if the requested iface type can be added to the current mode
1760// with the iface combination that is already active.
1761bool WifiChip::canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(
1762 IfaceType requested_type) {
Roshan Piuscc338202017-11-02 13:54:09 -07001763 if (!isValidModeId(current_mode_id_)) {
1764 LOG(ERROR) << "Chip not configured in a mode yet";
1765 return false;
1766 }
1767 const auto combinations = getCurrentModeIfaceCombinations();
1768 for (const auto& combination : combinations) {
1769 const auto expanded_combos = expandIfaceCombinations(combination);
1770 for (const auto& expanded_combo : expanded_combos) {
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001771 if (canExpandedIfaceComboSupportIfaceOfTypeWithCurrentIfaces(
1772 expanded_combo, requested_type)) {
Roshan Piuscc338202017-11-02 13:54:09 -07001773 return true;
1774 }
1775 }
1776 }
1777 return false;
1778}
1779
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001780// Note: This does not consider ifaces already active. It only checks if the
1781// provided expanded iface combination can support the requested combo.
1782bool WifiChip::canExpandedIfaceComboSupportIfaceCombo(
1783 const std::map<IfaceType, size_t>& expanded_combo,
1784 const std::map<IfaceType, size_t>& req_combo) {
1785 // Check if we have space for 1 more iface of |type| in this combo
1786 for (const auto type :
1787 {IfaceType::AP, IfaceType::NAN, IfaceType::P2P, IfaceType::STA}) {
1788 if (req_combo.count(type) == 0) {
1789 // Iface of "type" not in the req_combo.
1790 continue;
1791 }
1792 size_t num_ifaces_needed = req_combo.at(type);
1793 size_t num_ifaces_allowed = expanded_combo.at(type);
1794 if (num_ifaces_needed > num_ifaces_allowed) {
1795 return false;
1796 }
1797 }
1798 return true;
1799}
1800// This method does the following:
1801// a) Enumerate all possible iface combos by expanding the current
1802// ChipIfaceCombination.
1803// b) Check if the requested iface combo can be added to the current mode.
1804// Note: This does not consider ifaces already active. It only checks if the
1805// current mode can support the requested combo.
1806bool WifiChip::canCurrentModeSupportIfaceCombo(
1807 const std::map<IfaceType, size_t>& req_combo) {
1808 if (!isValidModeId(current_mode_id_)) {
1809 LOG(ERROR) << "Chip not configured in a mode yet";
1810 return false;
1811 }
1812 const auto combinations = getCurrentModeIfaceCombinations();
1813 for (const auto& combination : combinations) {
1814 const auto expanded_combos = expandIfaceCombinations(combination);
1815 for (const auto& expanded_combo : expanded_combos) {
1816 if (canExpandedIfaceComboSupportIfaceCombo(expanded_combo,
1817 req_combo)) {
1818 return true;
1819 }
1820 }
1821 }
1822 return false;
1823}
1824
1825// This method does the following:
1826// a) Enumerate all possible iface combos by expanding the current
1827// ChipIfaceCombination.
1828// b) Check if the requested iface type can be added to the current mode.
1829bool WifiChip::canCurrentModeSupportIfaceOfType(IfaceType requested_type) {
lesl261818b2020-11-27 12:37:35 +08001830 // Check if we can support at least 1 iface of type.
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001831 std::map<IfaceType, size_t> req_iface_combo;
1832 req_iface_combo[requested_type] = 1;
1833 return canCurrentModeSupportIfaceCombo(req_iface_combo);
1834}
1835
Roshan Piuscc338202017-11-02 13:54:09 -07001836bool WifiChip::isValidModeId(ChipModeId mode_id) {
1837 for (const auto& mode : modes_) {
1838 if (mode.id == mode_id) {
1839 return true;
1840 }
1841 }
1842 return false;
1843}
1844
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001845bool WifiChip::isStaApConcurrencyAllowedInCurrentMode() {
lesl261818b2020-11-27 12:37:35 +08001846 // Check if we can support at least 1 STA & 1 AP concurrently.
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001847 std::map<IfaceType, size_t> req_iface_combo;
1848 req_iface_combo[IfaceType::AP] = 1;
1849 req_iface_combo[IfaceType::STA] = 1;
1850 return canCurrentModeSupportIfaceCombo(req_iface_combo);
1851}
1852
lesl261818b2020-11-27 12:37:35 +08001853bool WifiChip::isDualStaConcurrencyAllowedInCurrentMode() {
1854 // Check if we can support at least 2 STA concurrently.
James Mattisd2e4c072019-05-22 16:14:48 -07001855 std::map<IfaceType, size_t> req_iface_combo;
lesl261818b2020-11-27 12:37:35 +08001856 req_iface_combo[IfaceType::STA] = 2;
James Mattisd2e4c072019-05-22 16:14:48 -07001857 return canCurrentModeSupportIfaceCombo(req_iface_combo);
1858}
1859
Roshan Pius6036c022019-03-27 10:41:58 -07001860std::string WifiChip::getFirstActiveWlanIfaceName() {
Roshan Pius444473f2019-04-19 08:41:20 -07001861 if (sta_ifaces_.size() > 0) return sta_ifaces_[0]->getName();
leslf012b652021-01-08 15:22:49 +08001862 if (ap_ifaces_.size() > 0) {
1863 // If the first active wlan iface is bridged iface.
1864 // Return first instance name.
1865 for (auto const& it : br_ifaces_ap_instances_) {
1866 if (it.first == ap_ifaces_[0]->getName()) {
1867 return it.second[0];
1868 }
1869 }
1870 return ap_ifaces_[0]->getName();
1871 }
Roshan Pius6036c022019-03-27 10:41:58 -07001872 // This could happen if the chip call is made before any STA/AP
1873 // iface is created. Default to wlan0 for such cases.
Roshan Pius444473f2019-04-19 08:41:20 -07001874 LOG(WARNING) << "No active wlan interfaces in use! Using default";
Jimmy Chen2dddd792019-12-23 17:50:39 +02001875 return getWlanIfaceNameWithType(IfaceType::STA, 0);
Roshan Pius6036c022019-03-27 10:41:58 -07001876}
1877
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001878// Return the first wlan (wlan0, wlan1 etc.) starting from |start_idx|
1879// not already in use.
1880// Note: This doesn't check the actual presence of these interfaces.
Jimmy Chen2dddd792019-12-23 17:50:39 +02001881std::string WifiChip::allocateApOrStaIfaceName(IfaceType type,
1882 uint32_t start_idx) {
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001883 for (unsigned idx = start_idx; idx < kMaxWlanIfaces; idx++) {
Jimmy Chen2dddd792019-12-23 17:50:39 +02001884 const auto ifname = getWlanIfaceNameWithType(type, idx);
lesl94d28242020-11-18 22:17:37 +08001885 if (findUsingNameFromBridgedApInstances(ifname)) continue;
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001886 if (findUsingName(ap_ifaces_, ifname)) continue;
1887 if (findUsingName(sta_ifaces_, ifname)) continue;
1888 return ifname;
Roshan Pius8e3c7ef2017-11-03 09:43:08 -07001889 }
1890 // This should never happen. We screwed up somewhere if it did.
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001891 CHECK(false) << "All wlan interfaces in use already!";
Roshan Pius8e3c7ef2017-11-03 09:43:08 -07001892 return {};
1893}
1894
lesl261818b2020-11-27 12:37:35 +08001895uint32_t WifiChip::startIdxOfApIface() {
1896 if (isDualStaConcurrencyAllowedInCurrentMode()) {
1897 // When the HAL support dual STAs, AP should start with idx 2.
1898 return 2;
1899 } else if (isStaApConcurrencyAllowedInCurrentMode()) {
1900 // When the HAL support STA + AP but it doesn't support dual STAs.
1901 // AP should start with idx 1.
1902 return 1;
1903 }
1904 // No concurrency support.
1905 return 0;
1906}
1907
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001908// AP iface names start with idx 1 for modes supporting
James Mattisd2e4c072019-05-22 16:14:48 -07001909// concurrent STA and not dual AP, else start with idx 0.
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001910std::string WifiChip::allocateApIfaceName() {
Roshan Pius78cb5992020-04-30 12:39:21 -07001911 // Check if we have a dedicated iface for AP.
lesl261818b2020-11-27 12:37:35 +08001912 std::vector<std::string> ifnames = getPredefinedApIfaceNames(false);
1913 if (!ifnames.empty()) {
1914 return ifnames[0];
Roshan Pius78cb5992020-04-30 12:39:21 -07001915 }
lesl261818b2020-11-27 12:37:35 +08001916 return allocateApOrStaIfaceName(IfaceType::AP, startIdxOfApIface());
1917}
1918
1919std::vector<std::string> WifiChip::allocateBridgedApInstanceNames() {
1920 // Check if we have a dedicated iface for AP.
1921 std::vector<std::string> instances = getPredefinedApIfaceNames(true);
1922 if (instances.size() == 2) {
1923 return instances;
1924 } else {
1925 int num_ifaces_need_to_allocate = 2 - instances.size();
1926 for (int i = 0; i < num_ifaces_need_to_allocate; i++) {
lesl5a46c952020-12-14 17:14:12 +08001927 std::string instance_name = allocateApOrStaIfaceName(
1928 IfaceType::AP, startIdxOfApIface() + i);
lesl261818b2020-11-27 12:37:35 +08001929 if (!instance_name.empty()) {
1930 instances.push_back(instance_name);
1931 }
1932 }
1933 }
1934 return instances;
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001935}
1936
1937// STA iface names start with idx 0.
1938// Primary STA iface will always be 0.
1939std::string WifiChip::allocateStaIfaceName() {
Jimmy Chen2dddd792019-12-23 17:50:39 +02001940 return allocateApOrStaIfaceName(IfaceType::STA, 0);
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001941}
1942
xshu5899e8e2018-01-09 15:36:03 -08001943bool WifiChip::writeRingbufferFilesInternal() {
1944 if (!removeOldFilesInternal()) {
1945 LOG(ERROR) << "Error occurred while deleting old tombstone files";
1946 return false;
1947 }
1948 // write ringbuffers to file
Veerendranath Jakkam25b3a6f2020-04-14 22:04:39 +05301949 {
1950 std::unique_lock<std::mutex> lk(lock_t);
xshuc905ea62021-07-11 19:57:02 -07001951 for (auto& item : ringbuffer_map_) {
1952 Ringbuffer& cur_buffer = item.second;
Veerendranath Jakkam25b3a6f2020-04-14 22:04:39 +05301953 if (cur_buffer.getData().empty()) {
1954 continue;
1955 }
1956 const std::string file_path_raw =
1957 kTombstoneFolderPath + item.first + "XXXXXXXXXX";
1958 const int dump_fd = mkstemp(makeCharVec(file_path_raw).data());
1959 if (dump_fd == -1) {
1960 PLOG(ERROR) << "create file failed";
1961 return false;
1962 }
1963 unique_fd file_auto_closer(dump_fd);
1964 for (const auto& cur_block : cur_buffer.getData()) {
1965 if (write(dump_fd, cur_block.data(),
1966 sizeof(cur_block[0]) * cur_block.size()) == -1) {
1967 PLOG(ERROR) << "Error writing to file";
1968 }
xshu5899e8e2018-01-09 15:36:03 -08001969 }
xshuc905ea62021-07-11 19:57:02 -07001970 cur_buffer.clear();
xshu5899e8e2018-01-09 15:36:03 -08001971 }
xshu0a0fe512020-07-22 17:53:37 -07001972 // unique_lock unlocked here
xshu5899e8e2018-01-09 15:36:03 -08001973 }
1974 return true;
1975}
1976
Jimmy Chen2dddd792019-12-23 17:50:39 +02001977std::string WifiChip::getWlanIfaceNameWithType(IfaceType type, unsigned idx) {
1978 std::string ifname;
1979
1980 // let the legacy hal override the interface name
1981 legacy_hal::wifi_error err =
1982 legacy_hal_.lock()->getSupportedIfaceName((uint32_t)type, ifname);
1983 if (err == legacy_hal::WIFI_SUCCESS) return ifname;
1984
1985 return getWlanIfaceName(idx);
1986}
1987
lesl94d28242020-11-18 22:17:37 +08001988void WifiChip::invalidateAndClearBridgedApAll() {
1989 for (auto const& it : br_ifaces_ap_instances_) {
1990 for (auto const& iface : it.second) {
Roshan Pius8c1a67b2021-03-02 10:00:23 -08001991 iface_util_->removeIfaceFromBridge(it.first, iface);
lesl94d28242020-11-18 22:17:37 +08001992 legacy_hal_.lock()->deleteVirtualInterface(iface);
1993 }
Roshan Pius8c1a67b2021-03-02 10:00:23 -08001994 iface_util_->deleteBridge(it.first);
lesl94d28242020-11-18 22:17:37 +08001995 }
1996 br_ifaces_ap_instances_.clear();
1997}
1998
1999void WifiChip::invalidateAndClearBridgedAp(const std::string& br_name) {
2000 if (br_name.empty()) return;
2001 // delete managed interfaces
2002 for (auto const& it : br_ifaces_ap_instances_) {
2003 if (it.first == br_name) {
2004 for (auto const& iface : it.second) {
Roshan Pius8c1a67b2021-03-02 10:00:23 -08002005 iface_util_->removeIfaceFromBridge(br_name, iface);
lesl94d28242020-11-18 22:17:37 +08002006 legacy_hal_.lock()->deleteVirtualInterface(iface);
2007 }
Roshan Pius8c1a67b2021-03-02 10:00:23 -08002008 iface_util_->deleteBridge(br_name);
lesl94d28242020-11-18 22:17:37 +08002009 br_ifaces_ap_instances_.erase(br_name);
2010 break;
2011 }
2012 }
2013 return;
2014}
2015
2016bool WifiChip::findUsingNameFromBridgedApInstances(const std::string& name) {
2017 for (auto const& it : br_ifaces_ap_instances_) {
2018 if (it.first == name) {
2019 return true;
2020 }
2021 for (auto const& iface : it.second) {
2022 if (iface == name) {
2023 return true;
2024 }
2025 }
2026 }
2027 return false;
2028}
2029
Roshan Pius79a99752016-10-04 13:03:58 -07002030} // namespace implementation
Jimmy Chend460df32019-11-29 17:31:22 +02002031} // namespace V1_5
Roshan Pius3c4e8a32016-10-03 14:53:58 -07002032} // namespace wifi
2033} // namespace hardware
2034} // namespace android