blob: ecf170abc2f773533244cef68fef28558585f80e [file] [log] [blame]
Roshan Pius3c4e8a32016-10-03 14:53:58 -07001/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
xshu5899e8e2018-01-09 15:36:03 -080017#include <fcntl.h>
18
Roshan Pius3c4e8a32016-10-03 14:53:58 -070019#include <android-base/logging.h>
xshu5899e8e2018-01-09 15:36:03 -080020#include <android-base/unique_fd.h>
Roshan Pius9377a0d2017-10-06 13:18:54 -070021#include <cutils/properties.h>
xshu5899e8e2018-01-09 15:36:03 -080022#include <sys/stat.h>
23#include <sys/sysmacros.h>
Roshan Pius3c4e8a32016-10-03 14:53:58 -070024
Roshan Pius3c868522016-10-27 12:43:49 -070025#include "hidl_return_util.h"
Roshan Piuse2d0ab52016-12-05 15:24:20 -080026#include "hidl_struct_util.h"
Roshan Pius3c868522016-10-27 12:43:49 -070027#include "wifi_chip.h"
Roshan Pius5c055462016-10-11 08:27:27 -070028#include "wifi_status_util.h"
Roshan Pius3c4e8a32016-10-03 14:53:58 -070029
Roshan Pius35d958c2016-10-06 16:47:38 -070030namespace {
Jong Wook Kimda830c92018-07-23 15:29:38 -070031using android::sp;
xshu5899e8e2018-01-09 15:36:03 -080032using android::base::unique_fd;
Roshan Pius35d958c2016-10-06 16:47:38 -070033using android::hardware::hidl_string;
Roshan Piusabcf78f2017-10-06 16:30:38 -070034using android::hardware::hidl_vec;
Roshan Pius2c06a3f2016-12-15 17:51:40 -080035using android::hardware::wifi::V1_0::ChipModeId;
Roshan Pius52947fb2016-11-18 11:38:07 -080036using android::hardware::wifi::V1_0::IfaceType;
Roshan Pius675609b2017-10-31 14:24:58 -070037using android::hardware::wifi::V1_0::IWifiChip;
Roshan Pius52947fb2016-11-18 11:38:07 -080038
xshu5899e8e2018-01-09 15:36:03 -080039constexpr char kCpioMagic[] = "070701";
Roger Wangb294c762018-11-02 15:34:39 +080040constexpr size_t kMaxBufferSizeBytes = 1024 * 1024 * 3;
41constexpr uint32_t kMaxRingBufferFileAgeSeconds = 60 * 60 * 10;
xshu37126c92018-04-13 16:24:45 -070042constexpr uint32_t kMaxRingBufferFileNum = 20;
xshu5899e8e2018-01-09 15:36:03 -080043constexpr char kTombstoneFolderPath[] = "/data/vendor/tombstones/wifi/";
Roshan Pius8574e7f2019-04-01 13:30:40 -070044constexpr char kActiveWlanIfaceNameProperty[] = "wifi.active.interface";
45constexpr char kNoActiveWlanIfaceNamePropertyValue[] = "";
46constexpr unsigned kMaxWlanIfaces = 5;
xshu5899e8e2018-01-09 15:36:03 -080047
Roshan Pius35d958c2016-10-06 16:47:38 -070048template <typename Iface>
Roshan Pius675609b2017-10-31 14:24:58 -070049void invalidateAndClear(std::vector<sp<Iface>>& ifaces, sp<Iface> iface) {
50 iface->invalidate();
51 ifaces.erase(std::remove(ifaces.begin(), ifaces.end(), iface),
52 ifaces.end());
53}
54
55template <typename Iface>
56void invalidateAndClearAll(std::vector<sp<Iface>>& ifaces) {
57 for (const auto& iface : ifaces) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070058 iface->invalidate();
Roshan Piusabcf78f2017-10-06 16:30:38 -070059 }
Roshan Pius675609b2017-10-31 14:24:58 -070060 ifaces.clear();
61}
62
63template <typename Iface>
64std::vector<hidl_string> getNames(std::vector<sp<Iface>>& ifaces) {
65 std::vector<hidl_string> names;
66 for (const auto& iface : ifaces) {
67 names.emplace_back(iface->getName());
68 }
69 return names;
70}
71
72template <typename Iface>
73sp<Iface> findUsingName(std::vector<sp<Iface>>& ifaces,
74 const std::string& name) {
75 std::vector<hidl_string> names;
76 for (const auto& iface : ifaces) {
77 if (name == iface->getName()) {
78 return iface;
79 }
80 }
81 return nullptr;
Roshan Pius35d958c2016-10-06 16:47:38 -070082}
Roshan Pius9377a0d2017-10-06 13:18:54 -070083
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -080084std::string getWlanIfaceName(unsigned idx) {
85 if (idx >= kMaxWlanIfaces) {
86 CHECK(false) << "Requested interface beyond wlan" << kMaxWlanIfaces;
87 return {};
88 }
Roshan Pius9377a0d2017-10-06 13:18:54 -070089
Roshan Pius8e3c7ef2017-11-03 09:43:08 -070090 std::array<char, PROPERTY_VALUE_MAX> buffer;
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -080091 if (idx == 0 || idx == 1) {
92 const char* altPropName =
93 (idx == 0) ? "wifi.interface" : "wifi.concurrent.interface";
Roshan Pius5b333462019-03-01 14:07:22 -080094 auto res = property_get(altPropName, buffer.data(), nullptr);
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -080095 if (res > 0) return buffer.data();
96 }
Roshan Pius5b333462019-03-01 14:07:22 -080097 std::string propName = "wifi.interface." + std::to_string(idx);
98 auto res = property_get(propName.c_str(), buffer.data(), nullptr);
99 if (res > 0) return buffer.data();
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800100
101 return "wlan" + std::to_string(idx);
Roshan Pius9377a0d2017-10-06 13:18:54 -0700102}
Roshan Pius9377a0d2017-10-06 13:18:54 -0700103
Roshan Pius78cb5992020-04-30 12:39:21 -0700104// Returns the dedicated iface name if one is defined.
105std::string getApIfaceName() {
106 std::array<char, PROPERTY_VALUE_MAX> buffer;
107 if (property_get("ro.vendor.wifi.sap.interface", buffer.data(), nullptr) ==
108 0) {
109 return {};
110 }
111 return buffer.data();
112}
113
Roshan Pius9377a0d2017-10-06 13:18:54 -0700114std::string getP2pIfaceName() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700115 std::array<char, PROPERTY_VALUE_MAX> buffer;
116 property_get("wifi.direct.interface", buffer.data(), "p2p0");
117 return buffer.data();
Roshan Pius9377a0d2017-10-06 13:18:54 -0700118}
119
Roshan Pius5ba0a902020-04-14 11:55:42 -0700120// Returns the dedicated iface name if one is defined.
121std::string getNanIfaceName() {
122 std::array<char, PROPERTY_VALUE_MAX> buffer;
123 if (property_get("wifi.aware.interface", buffer.data(), nullptr) == 0) {
124 return {};
125 }
126 return buffer.data();
127}
128
Roshan Pius8574e7f2019-04-01 13:30:40 -0700129void setActiveWlanIfaceNameProperty(const std::string& ifname) {
130 auto res = property_set(kActiveWlanIfaceNameProperty, ifname.data());
131 if (res != 0) {
132 PLOG(ERROR) << "Failed to set active wlan iface name property";
133 }
134}
135
xshu37126c92018-04-13 16:24:45 -0700136// delete files that meet either conditions:
137// 1. older than a predefined time in the wifi tombstone dir.
138// 2. Files in excess to a predefined amount, starting from the oldest ones
xshu5899e8e2018-01-09 15:36:03 -0800139bool removeOldFilesInternal() {
140 time_t now = time(0);
141 const time_t delete_files_before = now - kMaxRingBufferFileAgeSeconds;
Josh Gaoa568e532018-06-04 18:16:00 -0700142 std::unique_ptr<DIR, decltype(&closedir)> dir_dump(
143 opendir(kTombstoneFolderPath), closedir);
xshu5899e8e2018-01-09 15:36:03 -0800144 if (!dir_dump) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800145 PLOG(ERROR) << "Failed to open directory";
xshu5899e8e2018-01-09 15:36:03 -0800146 return false;
147 }
xshu5899e8e2018-01-09 15:36:03 -0800148 struct dirent* dp;
149 bool success = true;
xshu37126c92018-04-13 16:24:45 -0700150 std::list<std::pair<const time_t, std::string>> valid_files;
Josh Gaoa568e532018-06-04 18:16:00 -0700151 while ((dp = readdir(dir_dump.get()))) {
xshu5899e8e2018-01-09 15:36:03 -0800152 if (dp->d_type != DT_REG) {
153 continue;
154 }
155 std::string cur_file_name(dp->d_name);
156 struct stat cur_file_stat;
157 std::string cur_file_path = kTombstoneFolderPath + cur_file_name;
xshu4cb33162018-01-24 15:40:06 -0800158 if (stat(cur_file_path.c_str(), &cur_file_stat) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800159 PLOG(ERROR) << "Failed to get file stat for " << cur_file_path;
xshu5899e8e2018-01-09 15:36:03 -0800160 success = false;
xshu4cb33162018-01-24 15:40:06 -0800161 continue;
162 }
xshu37126c92018-04-13 16:24:45 -0700163 const time_t cur_file_time = cur_file_stat.st_mtime;
164 valid_files.push_back(
165 std::pair<const time_t, std::string>(cur_file_time, cur_file_path));
166 }
167 valid_files.sort(); // sort the list of files by last modified time from
168 // small to big.
169 uint32_t cur_file_count = valid_files.size();
170 for (auto cur_file : valid_files) {
171 if (cur_file_count > kMaxRingBufferFileNum ||
172 cur_file.first < delete_files_before) {
173 if (unlink(cur_file.second.c_str()) != 0) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800174 PLOG(ERROR) << "Error deleting file";
xshu37126c92018-04-13 16:24:45 -0700175 success = false;
176 }
177 cur_file_count--;
178 } else {
179 break;
xshu5899e8e2018-01-09 15:36:03 -0800180 }
181 }
182 return success;
183}
184
xshu4cb33162018-01-24 15:40:06 -0800185// Helper function for |cpioArchiveFilesInDir|
186bool cpioWriteHeader(int out_fd, struct stat& st, const char* file_name,
187 size_t file_name_len) {
188 std::array<char, 32 * 1024> read_buf;
189 ssize_t llen =
190 sprintf(read_buf.data(),
191 "%s%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X",
192 kCpioMagic, static_cast<int>(st.st_ino), st.st_mode, st.st_uid,
193 st.st_gid, static_cast<int>(st.st_nlink),
194 static_cast<int>(st.st_mtime), static_cast<int>(st.st_size),
195 major(st.st_dev), minor(st.st_dev), major(st.st_rdev),
196 minor(st.st_rdev), static_cast<uint32_t>(file_name_len), 0);
197 if (write(out_fd, read_buf.data(), llen) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800198 PLOG(ERROR) << "Error writing cpio header to file " << file_name;
xshu4cb33162018-01-24 15:40:06 -0800199 return false;
200 }
201 if (write(out_fd, file_name, file_name_len) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800202 PLOG(ERROR) << "Error writing filename to file " << file_name;
xshu4cb33162018-01-24 15:40:06 -0800203 return false;
204 }
205
206 // NUL Pad header up to 4 multiple bytes.
207 llen = (llen + file_name_len) % 4;
208 if (llen != 0) {
209 const uint32_t zero = 0;
210 if (write(out_fd, &zero, 4 - llen) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800211 PLOG(ERROR) << "Error padding 0s to file " << file_name;
xshu4cb33162018-01-24 15:40:06 -0800212 return false;
213 }
214 }
215 return true;
216}
217
218// Helper function for |cpioArchiveFilesInDir|
219size_t cpioWriteFileContent(int fd_read, int out_fd, struct stat& st) {
220 // writing content of file
221 std::array<char, 32 * 1024> read_buf;
222 ssize_t llen = st.st_size;
223 size_t n_error = 0;
224 while (llen > 0) {
225 ssize_t bytes_read = read(fd_read, read_buf.data(), read_buf.size());
226 if (bytes_read == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800227 PLOG(ERROR) << "Error reading file";
xshu4cb33162018-01-24 15:40:06 -0800228 return ++n_error;
229 }
230 llen -= bytes_read;
231 if (write(out_fd, read_buf.data(), bytes_read) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800232 PLOG(ERROR) << "Error writing data to file";
xshu4cb33162018-01-24 15:40:06 -0800233 return ++n_error;
234 }
235 if (bytes_read == 0) { // this should never happen, but just in case
236 // to unstuck from while loop
Elliott Hughes4db4add2019-03-08 12:42:57 -0800237 PLOG(ERROR) << "Unexpected read result";
xshu4cb33162018-01-24 15:40:06 -0800238 n_error++;
239 break;
240 }
241 }
242 llen = st.st_size % 4;
243 if (llen != 0) {
244 const uint32_t zero = 0;
245 if (write(out_fd, &zero, 4 - llen) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800246 PLOG(ERROR) << "Error padding 0s to file";
xshu4cb33162018-01-24 15:40:06 -0800247 return ++n_error;
248 }
249 }
250 return n_error;
251}
252
253// Helper function for |cpioArchiveFilesInDir|
254bool cpioWriteFileTrailer(int out_fd) {
255 std::array<char, 4096> read_buf;
256 read_buf.fill(0);
257 if (write(out_fd, read_buf.data(),
258 sprintf(read_buf.data(), "070701%040X%056X%08XTRAILER!!!", 1,
259 0x0b, 0) +
260 4) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800261 PLOG(ERROR) << "Error writing trailing bytes";
xshu4cb33162018-01-24 15:40:06 -0800262 return false;
263 }
264 return true;
265}
266
xshu5899e8e2018-01-09 15:36:03 -0800267// Archives all files in |input_dir| and writes result into |out_fd|
268// Logic obtained from //external/toybox/toys/posix/cpio.c "Output cpio archive"
269// portion
xshu4cb33162018-01-24 15:40:06 -0800270size_t cpioArchiveFilesInDir(int out_fd, const char* input_dir) {
xshu5899e8e2018-01-09 15:36:03 -0800271 struct dirent* dp;
272 size_t n_error = 0;
Josh Gaoa568e532018-06-04 18:16:00 -0700273 std::unique_ptr<DIR, decltype(&closedir)> dir_dump(opendir(input_dir),
274 closedir);
xshu5899e8e2018-01-09 15:36:03 -0800275 if (!dir_dump) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800276 PLOG(ERROR) << "Failed to open directory";
xshu4cb33162018-01-24 15:40:06 -0800277 return ++n_error;
xshu5899e8e2018-01-09 15:36:03 -0800278 }
Josh Gaoa568e532018-06-04 18:16:00 -0700279 while ((dp = readdir(dir_dump.get()))) {
xshu5899e8e2018-01-09 15:36:03 -0800280 if (dp->d_type != DT_REG) {
281 continue;
282 }
283 std::string cur_file_name(dp->d_name);
xshu5899e8e2018-01-09 15:36:03 -0800284 struct stat st;
xshu5899e8e2018-01-09 15:36:03 -0800285 const std::string cur_file_path = kTombstoneFolderPath + cur_file_name;
xshu4cb33162018-01-24 15:40:06 -0800286 if (stat(cur_file_path.c_str(), &st) == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800287 PLOG(ERROR) << "Failed to get file stat for " << cur_file_path;
xshu5899e8e2018-01-09 15:36:03 -0800288 n_error++;
xshu4cb33162018-01-24 15:40:06 -0800289 continue;
290 }
291 const int fd_read = open(cur_file_path.c_str(), O_RDONLY);
292 if (fd_read == -1) {
Elliott Hughes4db4add2019-03-08 12:42:57 -0800293 PLOG(ERROR) << "Failed to open file " << cur_file_path;
xshu4cb33162018-01-24 15:40:06 -0800294 n_error++;
295 continue;
296 }
xshuf392fb42020-08-13 16:57:00 -0700297 std::string file_name_with_last_modified_time =
298 cur_file_name + "-" + std::to_string(st.st_mtime);
299 // string.size() does not include the null terminator. The cpio FreeBSD
300 // file header expects the null character to be included in the length.
301 const size_t file_name_len =
302 file_name_with_last_modified_time.size() + 1;
xshu4cb33162018-01-24 15:40:06 -0800303 unique_fd file_auto_closer(fd_read);
xshuf392fb42020-08-13 16:57:00 -0700304 if (!cpioWriteHeader(out_fd, st,
305 file_name_with_last_modified_time.c_str(),
xshu4cb33162018-01-24 15:40:06 -0800306 file_name_len)) {
307 return ++n_error;
308 }
309 size_t write_error = cpioWriteFileContent(fd_read, out_fd, st);
310 if (write_error) {
311 return n_error + write_error;
xshu5899e8e2018-01-09 15:36:03 -0800312 }
313 }
xshu4cb33162018-01-24 15:40:06 -0800314 if (!cpioWriteFileTrailer(out_fd)) {
315 return ++n_error;
xshu5899e8e2018-01-09 15:36:03 -0800316 }
317 return n_error;
318}
319
320// Helper function to create a non-const char*.
321std::vector<char> makeCharVec(const std::string& str) {
322 std::vector<char> vec(str.size() + 1);
323 vec.assign(str.begin(), str.end());
324 vec.push_back('\0');
325 return vec;
326}
327
Roshan Piusabcf78f2017-10-06 16:30:38 -0700328} // namespace
Roshan Pius35d958c2016-10-06 16:47:38 -0700329
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700330namespace android {
331namespace hardware {
332namespace wifi {
Jimmy Chend460df32019-11-29 17:31:22 +0200333namespace V1_5 {
Roshan Pius79a99752016-10-04 13:03:58 -0700334namespace implementation {
Roshan Pius3c868522016-10-27 12:43:49 -0700335using hidl_return_util::validateAndCall;
Roshan Piusba38d9c2017-12-08 07:32:08 -0800336using hidl_return_util::validateAndCallWithLock;
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700337
Roshan Pius52947fb2016-11-18 11:38:07 -0800338WifiChip::WifiChip(
Jimmy Chen2dddd792019-12-23 17:50:39 +0200339 ChipId chip_id, bool is_primary,
340 const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
Roshan Pius200a17d2017-11-01 13:03:35 -0700341 const std::weak_ptr<mode_controller::WifiModeController> mode_controller,
Roshan Pius99dab382019-02-14 07:57:10 -0800342 const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util,
Ahmed ElArabawy2134bf72020-06-18 15:07:12 -0700343 const std::weak_ptr<feature_flags::WifiFeatureFlags> feature_flags,
344 const std::function<void(const std::string&)>& handler)
Roshan Pius52947fb2016-11-18 11:38:07 -0800345 : chip_id_(chip_id),
346 legacy_hal_(legacy_hal),
347 mode_controller_(mode_controller),
Roshan Pius99dab382019-02-14 07:57:10 -0800348 iface_util_(iface_util),
Roshan Pius52947fb2016-11-18 11:38:07 -0800349 is_valid_(true),
Tomasz Wasilczykb424da72018-11-15 11:52:57 -0800350 current_mode_id_(feature_flags::chip_mode_ids::kInvalid),
Jimmy Chen2dddd792019-12-23 17:50:39 +0200351 modes_(feature_flags.lock()->getChipModes(is_primary)),
Ahmed ElArabawy2134bf72020-06-18 15:07:12 -0700352 debug_ring_buffer_cb_registered_(false),
353 subsystemCallbackHandler_(handler) {
Roshan Pius8574e7f2019-04-01 13:30:40 -0700354 setActiveWlanIfaceNameProperty(kNoActiveWlanIfaceNamePropertyValue);
355}
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700356
Roshan Piusaabe5752016-09-29 09:03:59 -0700357void WifiChip::invalidate() {
xshu37126c92018-04-13 16:24:45 -0700358 if (!writeRingbufferFilesInternal()) {
359 LOG(ERROR) << "Error writing files to flash";
360 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700361 invalidateAndRemoveAllIfaces();
Roshan Pius8574e7f2019-04-01 13:30:40 -0700362 setActiveWlanIfaceNameProperty(kNoActiveWlanIfaceNamePropertyValue);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700363 legacy_hal_.reset();
364 event_cb_handler_.invalidate();
365 is_valid_ = false;
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700366}
367
Roshan Piusabcf78f2017-10-06 16:30:38 -0700368bool WifiChip::isValid() { return is_valid_; }
Roshan Pius3c868522016-10-27 12:43:49 -0700369
Jimmy Chend460df32019-11-29 17:31:22 +0200370std::set<sp<V1_4::IWifiChipEventCallback>> WifiChip::getEventCallbacks() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700371 return event_cb_handler_.getCallbacks();
Roshan Pius203cb032016-12-14 17:41:20 -0800372}
373
Roshan Pius5c055462016-10-11 08:27:27 -0700374Return<void> WifiChip::getId(getId_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700375 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
376 &WifiChip::getIdInternal, hidl_status_cb);
Roshan Piuscd566bd2016-10-10 08:03:42 -0700377}
378
Jong Wook Kimda830c92018-07-23 15:29:38 -0700379// Deprecated support for this callback
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700380Return<void> WifiChip::registerEventCallback(
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800381 const sp<V1_0::IWifiChipEventCallback>& event_callback,
Roshan Pius5c055462016-10-11 08:27:27 -0700382 registerEventCallback_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700383 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
384 &WifiChip::registerEventCallbackInternal,
385 hidl_status_cb, event_callback);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700386}
387
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700388Return<void> WifiChip::getCapabilities(getCapabilities_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700389 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
390 &WifiChip::getCapabilitiesInternal, hidl_status_cb);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700391}
392
Roshan Pius5c055462016-10-11 08:27:27 -0700393Return<void> WifiChip::getAvailableModes(getAvailableModes_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700394 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
395 &WifiChip::getAvailableModesInternal,
396 hidl_status_cb);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700397}
398
Roshan Pius2c06a3f2016-12-15 17:51:40 -0800399Return<void> WifiChip::configureChip(ChipModeId mode_id,
Roshan Pius5c055462016-10-11 08:27:27 -0700400 configureChip_cb hidl_status_cb) {
Roshan Piusba38d9c2017-12-08 07:32:08 -0800401 return validateAndCallWithLock(
402 this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
403 &WifiChip::configureChipInternal, hidl_status_cb, mode_id);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700404}
405
Roshan Pius5c055462016-10-11 08:27:27 -0700406Return<void> WifiChip::getMode(getMode_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700407 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
408 &WifiChip::getModeInternal, hidl_status_cb);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700409}
410
Roshan Pius5c055462016-10-11 08:27:27 -0700411Return<void> WifiChip::requestChipDebugInfo(
412 requestChipDebugInfo_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700413 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
414 &WifiChip::requestChipDebugInfoInternal,
415 hidl_status_cb);
Roshan Pius5c055462016-10-11 08:27:27 -0700416}
417
418Return<void> WifiChip::requestDriverDebugDump(
419 requestDriverDebugDump_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700420 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
421 &WifiChip::requestDriverDebugDumpInternal,
422 hidl_status_cb);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700423}
424
Roshan Pius5c055462016-10-11 08:27:27 -0700425Return<void> WifiChip::requestFirmwareDebugDump(
426 requestFirmwareDebugDump_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700427 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
428 &WifiChip::requestFirmwareDebugDumpInternal,
429 hidl_status_cb);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700430}
431
Roshan Pius5c055462016-10-11 08:27:27 -0700432Return<void> WifiChip::createApIface(createApIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700433 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
434 &WifiChip::createApIfaceInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700435}
436
Roshan Pius5c055462016-10-11 08:27:27 -0700437Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700438 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
439 &WifiChip::getApIfaceNamesInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700440}
441
Roshan Pius5c055462016-10-11 08:27:27 -0700442Return<void> WifiChip::getApIface(const hidl_string& ifname,
443 getApIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700444 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
445 &WifiChip::getApIfaceInternal, hidl_status_cb,
446 ifname);
Roshan Pius35d958c2016-10-06 16:47:38 -0700447}
448
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800449Return<void> WifiChip::removeApIface(const hidl_string& ifname,
450 removeApIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700451 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
452 &WifiChip::removeApIfaceInternal, hidl_status_cb,
453 ifname);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800454}
455
Roshan Pius5c055462016-10-11 08:27:27 -0700456Return<void> WifiChip::createNanIface(createNanIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700457 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
458 &WifiChip::createNanIfaceInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700459}
460
Roshan Pius5c055462016-10-11 08:27:27 -0700461Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700462 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
463 &WifiChip::getNanIfaceNamesInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700464}
465
466Return<void> WifiChip::getNanIface(const hidl_string& ifname,
Roshan Pius5c055462016-10-11 08:27:27 -0700467 getNanIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700468 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
469 &WifiChip::getNanIfaceInternal, hidl_status_cb,
470 ifname);
Roshan Pius35d958c2016-10-06 16:47:38 -0700471}
472
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800473Return<void> WifiChip::removeNanIface(const hidl_string& ifname,
474 removeNanIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700475 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
476 &WifiChip::removeNanIfaceInternal, hidl_status_cb,
477 ifname);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800478}
479
Roshan Pius5c055462016-10-11 08:27:27 -0700480Return<void> WifiChip::createP2pIface(createP2pIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700481 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
482 &WifiChip::createP2pIfaceInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700483}
484
Roshan Pius5c055462016-10-11 08:27:27 -0700485Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700486 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
487 &WifiChip::getP2pIfaceNamesInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700488}
489
490Return<void> WifiChip::getP2pIface(const hidl_string& ifname,
Roshan Pius5c055462016-10-11 08:27:27 -0700491 getP2pIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700492 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
493 &WifiChip::getP2pIfaceInternal, hidl_status_cb,
494 ifname);
Roshan Pius35d958c2016-10-06 16:47:38 -0700495}
496
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800497Return<void> WifiChip::removeP2pIface(const hidl_string& ifname,
498 removeP2pIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700499 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
500 &WifiChip::removeP2pIfaceInternal, hidl_status_cb,
501 ifname);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800502}
503
Roshan Pius5c055462016-10-11 08:27:27 -0700504Return<void> WifiChip::createStaIface(createStaIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700505 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
506 &WifiChip::createStaIfaceInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700507}
508
Roshan Pius5c055462016-10-11 08:27:27 -0700509Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700510 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
511 &WifiChip::getStaIfaceNamesInternal, hidl_status_cb);
Roshan Pius35d958c2016-10-06 16:47:38 -0700512}
513
514Return<void> WifiChip::getStaIface(const hidl_string& ifname,
Roshan Pius5c055462016-10-11 08:27:27 -0700515 getStaIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700516 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
517 &WifiChip::getStaIfaceInternal, hidl_status_cb,
518 ifname);
Roshan Pius35d958c2016-10-06 16:47:38 -0700519}
520
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800521Return<void> WifiChip::removeStaIface(const hidl_string& ifname,
522 removeStaIface_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700523 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
524 &WifiChip::removeStaIfaceInternal, hidl_status_cb,
525 ifname);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800526}
527
Roshan Pius5c055462016-10-11 08:27:27 -0700528Return<void> WifiChip::createRttController(
529 const sp<IWifiIface>& bound_iface, createRttController_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700530 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
531 &WifiChip::createRttControllerInternal,
532 hidl_status_cb, bound_iface);
Roshan Pius59268282016-10-06 20:23:47 -0700533}
534
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700535Return<void> WifiChip::getDebugRingBuffersStatus(
536 getDebugRingBuffersStatus_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700537 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
538 &WifiChip::getDebugRingBuffersStatusInternal,
539 hidl_status_cb);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700540}
541
542Return<void> WifiChip::startLoggingToDebugRingBuffer(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700543 const hidl_string& ring_name, WifiDebugRingBufferVerboseLevel verbose_level,
544 uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes,
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700545 startLoggingToDebugRingBuffer_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700546 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
547 &WifiChip::startLoggingToDebugRingBufferInternal,
548 hidl_status_cb, ring_name, verbose_level,
549 max_interval_in_sec, min_data_size_in_bytes);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700550}
551
552Return<void> WifiChip::forceDumpToDebugRingBuffer(
553 const hidl_string& ring_name,
554 forceDumpToDebugRingBuffer_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700555 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
556 &WifiChip::forceDumpToDebugRingBufferInternal,
557 hidl_status_cb, ring_name);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700558}
559
Roger Wangb294c762018-11-02 15:34:39 +0800560Return<void> WifiChip::flushRingBufferToFile(
561 flushRingBufferToFile_cb hidl_status_cb) {
562 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
563 &WifiChip::flushRingBufferToFileInternal,
564 hidl_status_cb);
565}
566
Roshan Pius8c0c8e92017-02-24 08:07:42 -0800567Return<void> WifiChip::stopLoggingToDebugRingBuffer(
568 stopLoggingToDebugRingBuffer_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700569 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
570 &WifiChip::stopLoggingToDebugRingBufferInternal,
571 hidl_status_cb);
Roshan Pius8c0c8e92017-02-24 08:07:42 -0800572}
573
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700574Return<void> WifiChip::getDebugHostWakeReasonStats(
575 getDebugHostWakeReasonStats_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700576 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
577 &WifiChip::getDebugHostWakeReasonStatsInternal,
578 hidl_status_cb);
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700579}
580
Roshan Pius203cb032016-12-14 17:41:20 -0800581Return<void> WifiChip::enableDebugErrorAlerts(
582 bool enable, enableDebugErrorAlerts_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700583 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
584 &WifiChip::enableDebugErrorAlertsInternal,
585 hidl_status_cb, enable);
Roshan Pius203cb032016-12-14 17:41:20 -0800586}
587
Roshan Pius735ff432017-07-25 08:48:08 -0700588Return<void> WifiChip::selectTxPowerScenario(
Jong Wook Kimda830c92018-07-23 15:29:38 -0700589 V1_1::IWifiChip::TxPowerScenario scenario,
590 selectTxPowerScenario_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700591 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
592 &WifiChip::selectTxPowerScenarioInternal,
593 hidl_status_cb, scenario);
Roshan Piusdbd83ef2017-06-20 12:05:40 -0700594}
595
Roshan Pius735ff432017-07-25 08:48:08 -0700596Return<void> WifiChip::resetTxPowerScenario(
597 resetTxPowerScenario_cb hidl_status_cb) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700598 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
599 &WifiChip::resetTxPowerScenarioInternal,
600 hidl_status_cb);
Roshan Piusdbd83ef2017-06-20 12:05:40 -0700601}
602
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700603Return<void> WifiChip::setLatencyMode(LatencyMode mode,
604 setLatencyMode_cb hidl_status_cb) {
605 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
606 &WifiChip::setLatencyModeInternal, hidl_status_cb,
607 mode);
608}
609
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800610Return<void> WifiChip::registerEventCallback_1_2(
Jong Wook Kimda830c92018-07-23 15:29:38 -0700611 const sp<V1_2::IWifiChipEventCallback>& event_callback,
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800612 registerEventCallback_cb hidl_status_cb) {
613 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
614 &WifiChip::registerEventCallbackInternal_1_2,
615 hidl_status_cb, event_callback);
616}
617
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800618Return<void> WifiChip::selectTxPowerScenario_1_2(
Jong Wook Kimda830c92018-07-23 15:29:38 -0700619 TxPowerScenario scenario, selectTxPowerScenario_cb hidl_status_cb) {
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800620 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
Jong Wook Kimda830c92018-07-23 15:29:38 -0700621 &WifiChip::selectTxPowerScenarioInternal_1_2,
622 hidl_status_cb, scenario);
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800623}
624
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700625Return<void> WifiChip::getCapabilities_1_3(getCapabilities_cb hidl_status_cb) {
626 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
627 &WifiChip::getCapabilitiesInternal_1_3,
628 hidl_status_cb);
629}
630
xshu5899e8e2018-01-09 15:36:03 -0800631Return<void> WifiChip::debug(const hidl_handle& handle,
632 const hidl_vec<hidl_string>&) {
633 if (handle != nullptr && handle->numFds >= 1) {
xshu0a0fe512020-07-22 17:53:37 -0700634 {
635 std::unique_lock<std::mutex> lk(lock_t);
636 for (const auto& item : ringbuffer_map_) {
637 forceDumpToDebugRingBufferInternal(item.first);
638 }
639 // unique_lock unlocked here
640 }
641 usleep(100 * 1000); // sleep for 100 milliseconds to wait for
642 // ringbuffer updates.
xshu5899e8e2018-01-09 15:36:03 -0800643 int fd = handle->data[0];
644 if (!writeRingbufferFilesInternal()) {
645 LOG(ERROR) << "Error writing files to flash";
646 }
xshu4cb33162018-01-24 15:40:06 -0800647 uint32_t n_error = cpioArchiveFilesInDir(fd, kTombstoneFolderPath);
xshu5899e8e2018-01-09 15:36:03 -0800648 if (n_error != 0) {
649 LOG(ERROR) << n_error << " errors occured in cpio function";
650 }
651 fsync(fd);
652 } else {
653 LOG(ERROR) << "File handle error";
654 }
655 return Void();
656}
657
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -0700658Return<void> WifiChip::createRttController_1_4(
659 const sp<IWifiIface>& bound_iface,
660 createRttController_1_4_cb hidl_status_cb) {
661 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
662 &WifiChip::createRttControllerInternal_1_4,
663 hidl_status_cb, bound_iface);
664}
665
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800666Return<void> WifiChip::registerEventCallback_1_4(
Jimmy Chend460df32019-11-29 17:31:22 +0200667 const sp<V1_4::IWifiChipEventCallback>& event_callback,
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800668 registerEventCallback_cb hidl_status_cb) {
669 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
670 &WifiChip::registerEventCallbackInternal_1_4,
671 hidl_status_cb, event_callback);
672}
673
Roshan Pius35d958c2016-10-06 16:47:38 -0700674void WifiChip::invalidateAndRemoveAllIfaces() {
Roshan Pius675609b2017-10-31 14:24:58 -0700675 invalidateAndClearAll(ap_ifaces_);
676 invalidateAndClearAll(nan_ifaces_);
677 invalidateAndClearAll(p2p_ifaces_);
678 invalidateAndClearAll(sta_ifaces_);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700679 // Since all the ifaces are invalid now, all RTT controller objects
680 // using those ifaces also need to be invalidated.
681 for (const auto& rtt : rtt_controllers_) {
682 rtt->invalidate();
683 }
684 rtt_controllers_.clear();
Roshan Pius35d958c2016-10-06 16:47:38 -0700685}
686
Roshan Pius82368502019-05-16 12:53:02 -0700687void WifiChip::invalidateAndRemoveDependencies(
688 const std::string& removed_iface_name) {
Jimmy Chen7a82ad82019-11-29 17:31:22 +0200689 for (auto it = nan_ifaces_.begin(); it != nan_ifaces_.end();) {
690 auto nan_iface = *it;
Roshan Pius82368502019-05-16 12:53:02 -0700691 if (nan_iface->getName() == removed_iface_name) {
Jimmy Chen7a82ad82019-11-29 17:31:22 +0200692 nan_iface->invalidate();
Roshan Pius82368502019-05-16 12:53:02 -0700693 for (const auto& callback : event_cb_handler_.getCallbacks()) {
694 if (!callback
695 ->onIfaceRemoved(IfaceType::NAN, removed_iface_name)
696 .isOk()) {
697 LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
698 }
699 }
Jimmy Chen7a82ad82019-11-29 17:31:22 +0200700 it = nan_ifaces_.erase(it);
701 } else {
702 ++it;
Roshan Pius82368502019-05-16 12:53:02 -0700703 }
704 }
Jimmy Chen7a82ad82019-11-29 17:31:22 +0200705
706 for (auto it = rtt_controllers_.begin(); it != rtt_controllers_.end();) {
707 auto rtt = *it;
Roshan Pius82368502019-05-16 12:53:02 -0700708 if (rtt->getIfaceName() == removed_iface_name) {
Jimmy Chen7a82ad82019-11-29 17:31:22 +0200709 rtt->invalidate();
710 it = rtt_controllers_.erase(it);
711 } else {
712 ++it;
Roshan Pius82368502019-05-16 12:53:02 -0700713 }
714 }
715}
716
Roshan Pius3c868522016-10-27 12:43:49 -0700717std::pair<WifiStatus, ChipId> WifiChip::getIdInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700718 return {createWifiStatus(WifiStatusCode::SUCCESS), chip_id_};
Roshan Pius3c868522016-10-27 12:43:49 -0700719}
720
721WifiStatus WifiChip::registerEventCallbackInternal(
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800722 const sp<V1_0::IWifiChipEventCallback>& /* event_callback */) {
723 // Deprecated support for this callback.
724 return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
Roshan Pius3c868522016-10-27 12:43:49 -0700725}
726
Roshan Pius7d08d7a2016-10-27 14:35:05 -0700727std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal() {
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700728 // Deprecated support for this callback.
729 return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), 0};
730}
731
Jimmy Chend460df32019-11-29 17:31:22 +0200732std::pair<WifiStatus, std::vector<V1_4::IWifiChip::ChipMode>>
Roshan Pius3c868522016-10-27 12:43:49 -0700733WifiChip::getAvailableModesInternal() {
Roshan Piuscc338202017-11-02 13:54:09 -0700734 return {createWifiStatus(WifiStatusCode::SUCCESS), modes_};
Roshan Pius3c868522016-10-27 12:43:49 -0700735}
736
Roshan Piusba38d9c2017-12-08 07:32:08 -0800737WifiStatus WifiChip::configureChipInternal(
738 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock,
739 ChipModeId mode_id) {
Roshan Piuscc338202017-11-02 13:54:09 -0700740 if (!isValidModeId(mode_id)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700741 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
742 }
743 if (mode_id == current_mode_id_) {
744 LOG(DEBUG) << "Already in the specified mode " << mode_id;
745 return createWifiStatus(WifiStatusCode::SUCCESS);
746 }
Roshan Piusba38d9c2017-12-08 07:32:08 -0800747 WifiStatus status = handleChipConfiguration(lock, mode_id);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700748 if (status.code != WifiStatusCode::SUCCESS) {
749 for (const auto& callback : event_cb_handler_.getCallbacks()) {
750 if (!callback->onChipReconfigureFailure(status).isOk()) {
751 LOG(ERROR)
752 << "Failed to invoke onChipReconfigureFailure callback";
753 }
754 }
755 return status;
756 }
Roshan Piusd37341f2017-01-31 13:13:28 -0800757 for (const auto& callback : event_cb_handler_.getCallbacks()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700758 if (!callback->onChipReconfigured(mode_id).isOk()) {
759 LOG(ERROR) << "Failed to invoke onChipReconfigured callback";
760 }
Roshan Pius52947fb2016-11-18 11:38:07 -0800761 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700762 current_mode_id_ = mode_id;
Roshan Piusba38d9c2017-12-08 07:32:08 -0800763 LOG(INFO) << "Configured chip in mode " << mode_id;
Roshan Pius8574e7f2019-04-01 13:30:40 -0700764 setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
Ahmed ElArabawy2134bf72020-06-18 15:07:12 -0700765
766 legacy_hal_.lock()->registerSubsystemRestartCallbackHandler(
767 subsystemCallbackHandler_);
768
Roshan Pius2c06a3f2016-12-15 17:51:40 -0800769 return status;
Roshan Pius3c868522016-10-27 12:43:49 -0700770}
771
772std::pair<WifiStatus, uint32_t> WifiChip::getModeInternal() {
Roshan Piuscc338202017-11-02 13:54:09 -0700773 if (!isValidModeId(current_mode_id_)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700774 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE),
775 current_mode_id_};
776 }
777 return {createWifiStatus(WifiStatusCode::SUCCESS), current_mode_id_};
Roshan Pius3c868522016-10-27 12:43:49 -0700778}
779
Jimmy Chend460df32019-11-29 17:31:22 +0200780std::pair<WifiStatus, V1_4::IWifiChip::ChipDebugInfo>
Roshan Pius3c868522016-10-27 12:43:49 -0700781WifiChip::requestChipDebugInfoInternal() {
Jimmy Chend460df32019-11-29 17:31:22 +0200782 V1_4::IWifiChip::ChipDebugInfo result;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700783 legacy_hal::wifi_error legacy_status;
784 std::string driver_desc;
Roshan Pius6036c022019-03-27 10:41:58 -0700785 const auto ifname = getFirstActiveWlanIfaceName();
Roshan Piusabcf78f2017-10-06 16:30:38 -0700786 std::tie(legacy_status, driver_desc) =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800787 legacy_hal_.lock()->getDriverVersion(ifname);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700788 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
789 LOG(ERROR) << "Failed to get driver version: "
790 << legacyErrorToString(legacy_status);
791 WifiStatus status = createWifiStatusFromLegacyError(
792 legacy_status, "failed to get driver version");
793 return {status, result};
794 }
795 result.driverDescription = driver_desc.c_str();
Roshan Pius3c868522016-10-27 12:43:49 -0700796
Roshan Piusabcf78f2017-10-06 16:30:38 -0700797 std::string firmware_desc;
798 std::tie(legacy_status, firmware_desc) =
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -0800799 legacy_hal_.lock()->getFirmwareVersion(ifname);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700800 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
801 LOG(ERROR) << "Failed to get firmware version: "
802 << legacyErrorToString(legacy_status);
803 WifiStatus status = createWifiStatusFromLegacyError(
804 legacy_status, "failed to get firmware version");
805 return {status, result};
806 }
807 result.firmwareDescription = firmware_desc.c_str();
Roshan Pius3c868522016-10-27 12:43:49 -0700808
Roshan Piusabcf78f2017-10-06 16:30:38 -0700809 return {createWifiStatus(WifiStatusCode::SUCCESS), result};
Roshan Pius3c868522016-10-27 12:43:49 -0700810}
811
812std::pair<WifiStatus, std::vector<uint8_t>>
813WifiChip::requestDriverDebugDumpInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700814 legacy_hal::wifi_error legacy_status;
815 std::vector<uint8_t> driver_dump;
816 std::tie(legacy_status, driver_dump) =
Roshan Pius6036c022019-03-27 10:41:58 -0700817 legacy_hal_.lock()->requestDriverMemoryDump(
818 getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -0700819 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
820 LOG(ERROR) << "Failed to get driver debug dump: "
821 << legacyErrorToString(legacy_status);
822 return {createWifiStatusFromLegacyError(legacy_status),
823 std::vector<uint8_t>()};
824 }
825 return {createWifiStatus(WifiStatusCode::SUCCESS), driver_dump};
Roshan Pius3c868522016-10-27 12:43:49 -0700826}
827
828std::pair<WifiStatus, std::vector<uint8_t>>
829WifiChip::requestFirmwareDebugDumpInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700830 legacy_hal::wifi_error legacy_status;
831 std::vector<uint8_t> firmware_dump;
832 std::tie(legacy_status, firmware_dump) =
Roshan Pius6036c022019-03-27 10:41:58 -0700833 legacy_hal_.lock()->requestFirmwareMemoryDump(
834 getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -0700835 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
836 LOG(ERROR) << "Failed to get firmware debug dump: "
837 << legacyErrorToString(legacy_status);
838 return {createWifiStatusFromLegacyError(legacy_status), {}};
839 }
840 return {createWifiStatus(WifiStatusCode::SUCCESS), firmware_dump};
Roshan Pius3c868522016-10-27 12:43:49 -0700841}
842
843std::pair<WifiStatus, sp<IWifiApIface>> WifiChip::createApIfaceInternal() {
Roshan Piusa3e5b7f2019-03-25 13:52:45 -0700844 if (!canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType::AP)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700845 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
Roshan Piusbc662202017-01-30 17:07:42 -0800846 }
Roshan Piusa3e5b7f2019-03-25 13:52:45 -0700847 std::string ifname = allocateApIfaceName();
Sunil Raviddab4bb2020-02-03 22:45:19 -0800848 legacy_hal::wifi_error legacy_status =
849 legacy_hal_.lock()->createVirtualInterface(
850 ifname,
851 hidl_struct_util::convertHidlIfaceTypeToLegacy(IfaceType::AP));
852 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
853 LOG(ERROR) << "Failed to add interface: " << ifname << " "
854 << legacyErrorToString(legacy_status);
855 return {createWifiStatusFromLegacyError(legacy_status), {}};
856 }
Patrik Fimml6beae322019-10-09 17:34:01 +0200857 sp<WifiApIface> iface = new WifiApIface(ifname, legacy_hal_, iface_util_);
Roshan Pius675609b2017-10-31 14:24:58 -0700858 ap_ifaces_.push_back(iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700859 for (const auto& callback : event_cb_handler_.getCallbacks()) {
860 if (!callback->onIfaceAdded(IfaceType::AP, ifname).isOk()) {
861 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
862 }
863 }
Roshan Pius8574e7f2019-04-01 13:30:40 -0700864 setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
Roshan Pius675609b2017-10-31 14:24:58 -0700865 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -0700866}
867
868std::pair<WifiStatus, std::vector<hidl_string>>
869WifiChip::getApIfaceNamesInternal() {
Roshan Pius675609b2017-10-31 14:24:58 -0700870 if (ap_ifaces_.empty()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700871 return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
872 }
Roshan Pius675609b2017-10-31 14:24:58 -0700873 return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(ap_ifaces_)};
Roshan Pius3c868522016-10-27 12:43:49 -0700874}
875
876std::pair<WifiStatus, sp<IWifiApIface>> WifiChip::getApIfaceInternal(
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800877 const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -0700878 const auto iface = findUsingName(ap_ifaces_, ifname);
879 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700880 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
881 }
Roshan Pius675609b2017-10-31 14:24:58 -0700882 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -0700883}
884
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800885WifiStatus WifiChip::removeApIfaceInternal(const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -0700886 const auto iface = findUsingName(ap_ifaces_, ifname);
887 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700888 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
Roshan Piusbc662202017-01-30 17:07:42 -0800889 }
Roshan Pius82368502019-05-16 12:53:02 -0700890 // Invalidate & remove any dependent objects first.
891 // Note: This is probably not required because we never create
892 // nan/rtt objects over AP iface. But, there is no harm to do it
893 // here and not make that assumption all over the place.
894 invalidateAndRemoveDependencies(ifname);
Sunil Raviddab4bb2020-02-03 22:45:19 -0800895 legacy_hal::wifi_error legacy_status =
896 legacy_hal_.lock()->deleteVirtualInterface(ifname);
897 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
898 LOG(ERROR) << "Failed to remove interface: " << ifname << " "
899 << legacyErrorToString(legacy_status);
900 }
Roshan Pius675609b2017-10-31 14:24:58 -0700901 invalidateAndClear(ap_ifaces_, iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700902 for (const auto& callback : event_cb_handler_.getCallbacks()) {
903 if (!callback->onIfaceRemoved(IfaceType::AP, ifname).isOk()) {
904 LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
905 }
906 }
Roshan Pius8574e7f2019-04-01 13:30:40 -0700907 setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -0700908 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800909}
910
Jimmy Chend460df32019-11-29 17:31:22 +0200911std::pair<WifiStatus, sp<V1_4::IWifiNanIface>>
912WifiChip::createNanIfaceInternal() {
Roshan Piusa3e5b7f2019-03-25 13:52:45 -0700913 if (!canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType::NAN)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700914 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
Etan Cohenc5700402017-03-08 16:43:38 -0800915 }
Roshan Pius5ba0a902020-04-14 11:55:42 -0700916 bool is_dedicated_iface = true;
917 std::string ifname = getNanIfaceName();
Nate Jiang63f34ed2020-05-20 23:22:51 -0700918 if (ifname.empty() || !iface_util_.lock()->ifNameToIndex(ifname)) {
Roshan Pius5ba0a902020-04-14 11:55:42 -0700919 // Use the first shared STA iface (wlan0) if a dedicated aware iface is
920 // not defined.
921 ifname = getFirstActiveWlanIfaceName();
922 is_dedicated_iface = false;
923 }
924 sp<WifiNanIface> iface =
925 new WifiNanIface(ifname, is_dedicated_iface, legacy_hal_, iface_util_);
Roshan Piuscc338202017-11-02 13:54:09 -0700926 nan_ifaces_.push_back(iface);
927 for (const auto& callback : event_cb_handler_.getCallbacks()) {
928 if (!callback->onIfaceAdded(IfaceType::NAN, ifname).isOk()) {
929 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
930 }
931 }
932 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -0700933}
934
935std::pair<WifiStatus, std::vector<hidl_string>>
936WifiChip::getNanIfaceNamesInternal() {
Roshan Pius675609b2017-10-31 14:24:58 -0700937 if (nan_ifaces_.empty()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700938 return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
939 }
Roshan Pius675609b2017-10-31 14:24:58 -0700940 return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(nan_ifaces_)};
Roshan Pius3c868522016-10-27 12:43:49 -0700941}
942
Jimmy Chend460df32019-11-29 17:31:22 +0200943std::pair<WifiStatus, sp<V1_4::IWifiNanIface>> WifiChip::getNanIfaceInternal(
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800944 const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -0700945 const auto iface = findUsingName(nan_ifaces_, ifname);
946 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700947 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
948 }
Roshan Pius675609b2017-10-31 14:24:58 -0700949 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -0700950}
951
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800952WifiStatus WifiChip::removeNanIfaceInternal(const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -0700953 const auto iface = findUsingName(nan_ifaces_, ifname);
954 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700955 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
Roshan Piusbc662202017-01-30 17:07:42 -0800956 }
Roshan Pius675609b2017-10-31 14:24:58 -0700957 invalidateAndClear(nan_ifaces_, iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700958 for (const auto& callback : event_cb_handler_.getCallbacks()) {
959 if (!callback->onIfaceRemoved(IfaceType::NAN, ifname).isOk()) {
960 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
961 }
962 }
963 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800964}
965
Roshan Pius3c868522016-10-27 12:43:49 -0700966std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::createP2pIfaceInternal() {
Roshan Piusa3e5b7f2019-03-25 13:52:45 -0700967 if (!canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType::P2P)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700968 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
Roshan Piusbc662202017-01-30 17:07:42 -0800969 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700970 std::string ifname = getP2pIfaceName();
Roshan Pius675609b2017-10-31 14:24:58 -0700971 sp<WifiP2pIface> iface = new WifiP2pIface(ifname, legacy_hal_);
972 p2p_ifaces_.push_back(iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700973 for (const auto& callback : event_cb_handler_.getCallbacks()) {
974 if (!callback->onIfaceAdded(IfaceType::P2P, ifname).isOk()) {
975 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
976 }
977 }
Roshan Pius675609b2017-10-31 14:24:58 -0700978 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -0700979}
980
981std::pair<WifiStatus, std::vector<hidl_string>>
982WifiChip::getP2pIfaceNamesInternal() {
Roshan Pius675609b2017-10-31 14:24:58 -0700983 if (p2p_ifaces_.empty()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700984 return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
985 }
Roshan Pius675609b2017-10-31 14:24:58 -0700986 return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(p2p_ifaces_)};
Roshan Pius3c868522016-10-27 12:43:49 -0700987}
988
989std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::getP2pIfaceInternal(
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800990 const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -0700991 const auto iface = findUsingName(p2p_ifaces_, ifname);
992 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700993 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
994 }
Roshan Pius675609b2017-10-31 14:24:58 -0700995 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -0700996}
997
Roshan Pius8b55e6f2016-12-09 12:05:12 -0800998WifiStatus WifiChip::removeP2pIfaceInternal(const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -0700999 const auto iface = findUsingName(p2p_ifaces_, ifname);
1000 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001001 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
Roshan Piusbc662202017-01-30 17:07:42 -08001002 }
Roshan Pius675609b2017-10-31 14:24:58 -07001003 invalidateAndClear(p2p_ifaces_, iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001004 for (const auto& callback : event_cb_handler_.getCallbacks()) {
1005 if (!callback->onIfaceRemoved(IfaceType::P2P, ifname).isOk()) {
1006 LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
1007 }
1008 }
1009 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001010}
1011
Ahmed ElArabawyb23485d2019-12-09 15:24:16 -08001012std::pair<WifiStatus, sp<V1_3::IWifiStaIface>>
1013WifiChip::createStaIfaceInternal() {
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001014 if (!canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType::STA)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001015 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
Roshan Piusbc662202017-01-30 17:07:42 -08001016 }
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001017 std::string ifname = allocateStaIfaceName();
Sunil Raviddab4bb2020-02-03 22:45:19 -08001018 legacy_hal::wifi_error legacy_status =
1019 legacy_hal_.lock()->createVirtualInterface(
1020 ifname,
1021 hidl_struct_util::convertHidlIfaceTypeToLegacy(IfaceType::STA));
1022 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1023 LOG(ERROR) << "Failed to add interface: " << ifname << " "
1024 << legacyErrorToString(legacy_status);
1025 return {createWifiStatusFromLegacyError(legacy_status), {}};
1026 }
Roshan Pius99dab382019-02-14 07:57:10 -08001027 sp<WifiStaIface> iface = new WifiStaIface(ifname, legacy_hal_, iface_util_);
Roshan Pius675609b2017-10-31 14:24:58 -07001028 sta_ifaces_.push_back(iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001029 for (const auto& callback : event_cb_handler_.getCallbacks()) {
1030 if (!callback->onIfaceAdded(IfaceType::STA, ifname).isOk()) {
1031 LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
1032 }
1033 }
Roshan Pius8574e7f2019-04-01 13:30:40 -07001034 setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
Roshan Pius675609b2017-10-31 14:24:58 -07001035 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -07001036}
1037
1038std::pair<WifiStatus, std::vector<hidl_string>>
1039WifiChip::getStaIfaceNamesInternal() {
Roshan Pius675609b2017-10-31 14:24:58 -07001040 if (sta_ifaces_.empty()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001041 return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
1042 }
Roshan Pius675609b2017-10-31 14:24:58 -07001043 return {createWifiStatus(WifiStatusCode::SUCCESS), getNames(sta_ifaces_)};
Roshan Pius3c868522016-10-27 12:43:49 -07001044}
1045
Ahmed ElArabawyb23485d2019-12-09 15:24:16 -08001046std::pair<WifiStatus, sp<V1_3::IWifiStaIface>> WifiChip::getStaIfaceInternal(
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001047 const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -07001048 const auto iface = findUsingName(sta_ifaces_, ifname);
1049 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001050 return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
1051 }
Roshan Pius675609b2017-10-31 14:24:58 -07001052 return {createWifiStatus(WifiStatusCode::SUCCESS), iface};
Roshan Pius3c868522016-10-27 12:43:49 -07001053}
1054
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001055WifiStatus WifiChip::removeStaIfaceInternal(const std::string& ifname) {
Roshan Pius675609b2017-10-31 14:24:58 -07001056 const auto iface = findUsingName(sta_ifaces_, ifname);
1057 if (!iface.get()) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001058 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
Roshan Piusbc662202017-01-30 17:07:42 -08001059 }
Roshan Pius82368502019-05-16 12:53:02 -07001060 // Invalidate & remove any dependent objects first.
1061 invalidateAndRemoveDependencies(ifname);
Sunil Raviddab4bb2020-02-03 22:45:19 -08001062 legacy_hal::wifi_error legacy_status =
1063 legacy_hal_.lock()->deleteVirtualInterface(ifname);
1064 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1065 LOG(ERROR) << "Failed to remove interface: " << ifname << " "
1066 << legacyErrorToString(legacy_status);
1067 }
Roshan Pius675609b2017-10-31 14:24:58 -07001068 invalidateAndClear(sta_ifaces_, iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001069 for (const auto& callback : event_cb_handler_.getCallbacks()) {
1070 if (!callback->onIfaceRemoved(IfaceType::STA, ifname).isOk()) {
1071 LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
1072 }
1073 }
Roshan Pius8574e7f2019-04-01 13:30:40 -07001074 setActiveWlanIfaceNameProperty(getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -07001075 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius8b55e6f2016-12-09 12:05:12 -08001076}
1077
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07001078std::pair<WifiStatus, sp<V1_0::IWifiRttController>>
1079WifiChip::createRttControllerInternal(const sp<IWifiIface>& /*bound_iface*/) {
1080 LOG(ERROR) << "createRttController is not supported on this HAL";
Ahmed ElArabawy36defb32019-12-29 21:24:27 -08001081 return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
Roshan Pius3c868522016-10-27 12:43:49 -07001082}
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001083
1084std::pair<WifiStatus, std::vector<WifiDebugRingBufferStatus>>
1085WifiChip::getDebugRingBuffersStatusInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001086 legacy_hal::wifi_error legacy_status;
1087 std::vector<legacy_hal::wifi_ring_buffer_status>
1088 legacy_ring_buffer_status_vec;
1089 std::tie(legacy_status, legacy_ring_buffer_status_vec) =
Roshan Pius6036c022019-03-27 10:41:58 -07001090 legacy_hal_.lock()->getRingBuffersStatus(getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -07001091 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1092 return {createWifiStatusFromLegacyError(legacy_status), {}};
1093 }
1094 std::vector<WifiDebugRingBufferStatus> hidl_ring_buffer_status_vec;
1095 if (!hidl_struct_util::convertLegacyVectorOfDebugRingBufferStatusToHidl(
1096 legacy_ring_buffer_status_vec, &hidl_ring_buffer_status_vec)) {
1097 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
1098 }
1099 return {createWifiStatus(WifiStatusCode::SUCCESS),
1100 hidl_ring_buffer_status_vec};
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001101}
1102
1103WifiStatus WifiChip::startLoggingToDebugRingBufferInternal(
Roshan Piusabcf78f2017-10-06 16:30:38 -07001104 const hidl_string& ring_name, WifiDebugRingBufferVerboseLevel verbose_level,
1105 uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes) {
1106 WifiStatus status = registerDebugRingBufferCallback();
1107 if (status.code != WifiStatusCode::SUCCESS) {
1108 return status;
1109 }
1110 legacy_hal::wifi_error legacy_status =
1111 legacy_hal_.lock()->startRingBufferLogging(
Roshan Pius6036c022019-03-27 10:41:58 -07001112 getFirstActiveWlanIfaceName(), ring_name,
Roshan Piusabcf78f2017-10-06 16:30:38 -07001113 static_cast<
1114 std::underlying_type<WifiDebugRingBufferVerboseLevel>::type>(
1115 verbose_level),
1116 max_interval_in_sec, min_data_size_in_bytes);
xshu5899e8e2018-01-09 15:36:03 -08001117 ringbuffer_map_.insert(std::pair<std::string, Ringbuffer>(
1118 ring_name, Ringbuffer(kMaxBufferSizeBytes)));
Roshan Piusa63b53f2019-11-18 11:03:13 -08001119 // if verbose logging enabled, turn up HAL daemon logging as well.
1120 if (verbose_level < WifiDebugRingBufferVerboseLevel::VERBOSE) {
1121 android::base::SetMinimumLogSeverity(android::base::DEBUG);
1122 } else {
1123 android::base::SetMinimumLogSeverity(android::base::VERBOSE);
1124 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001125 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001126}
1127
1128WifiStatus WifiChip::forceDumpToDebugRingBufferInternal(
Roshan Piuse2d0ab52016-12-05 15:24:20 -08001129 const hidl_string& ring_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001130 WifiStatus status = registerDebugRingBufferCallback();
1131 if (status.code != WifiStatusCode::SUCCESS) {
1132 return status;
1133 }
1134 legacy_hal::wifi_error legacy_status =
Roshan Pius6036c022019-03-27 10:41:58 -07001135 legacy_hal_.lock()->getRingBufferData(getFirstActiveWlanIfaceName(),
1136 ring_name);
xshu5899e8e2018-01-09 15:36:03 -08001137
Roshan Piusabcf78f2017-10-06 16:30:38 -07001138 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001139}
1140
Roger Wangb294c762018-11-02 15:34:39 +08001141WifiStatus WifiChip::flushRingBufferToFileInternal() {
1142 if (!writeRingbufferFilesInternal()) {
1143 LOG(ERROR) << "Error writing files to flash";
1144 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
1145 }
1146 return createWifiStatus(WifiStatusCode::SUCCESS);
1147}
1148
Roshan Pius8c0c8e92017-02-24 08:07:42 -08001149WifiStatus WifiChip::stopLoggingToDebugRingBufferInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001150 legacy_hal::wifi_error legacy_status =
1151 legacy_hal_.lock()->deregisterRingBufferCallbackHandler(
Roshan Pius6036c022019-03-27 10:41:58 -07001152 getFirstActiveWlanIfaceName());
xshu0a0fe512020-07-22 17:53:37 -07001153 if (legacy_status == legacy_hal::WIFI_SUCCESS) {
1154 debug_ring_buffer_cb_registered_ = false;
1155 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001156 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius8c0c8e92017-02-24 08:07:42 -08001157}
1158
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001159std::pair<WifiStatus, WifiDebugHostWakeReasonStats>
1160WifiChip::getDebugHostWakeReasonStatsInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001161 legacy_hal::wifi_error legacy_status;
1162 legacy_hal::WakeReasonStats legacy_stats;
1163 std::tie(legacy_status, legacy_stats) =
Roshan Pius6036c022019-03-27 10:41:58 -07001164 legacy_hal_.lock()->getWakeReasonStats(getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -07001165 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1166 return {createWifiStatusFromLegacyError(legacy_status), {}};
1167 }
1168 WifiDebugHostWakeReasonStats hidl_stats;
1169 if (!hidl_struct_util::convertLegacyWakeReasonStatsToHidl(legacy_stats,
1170 &hidl_stats)) {
1171 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
1172 }
1173 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_stats};
Roshan Pius7d08d7a2016-10-27 14:35:05 -07001174}
1175
Roshan Pius203cb032016-12-14 17:41:20 -08001176WifiStatus WifiChip::enableDebugErrorAlertsInternal(bool enable) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001177 legacy_hal::wifi_error legacy_status;
1178 if (enable) {
1179 android::wp<WifiChip> weak_ptr_this(this);
1180 const auto& on_alert_callback = [weak_ptr_this](
1181 int32_t error_code,
1182 std::vector<uint8_t> debug_data) {
1183 const auto shared_ptr_this = weak_ptr_this.promote();
1184 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
1185 LOG(ERROR) << "Callback invoked on an invalid object";
1186 return;
1187 }
1188 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
1189 if (!callback->onDebugErrorAlert(error_code, debug_data)
1190 .isOk()) {
1191 LOG(ERROR) << "Failed to invoke onDebugErrorAlert callback";
1192 }
1193 }
1194 };
1195 legacy_status = legacy_hal_.lock()->registerErrorAlertCallbackHandler(
Roshan Pius6036c022019-03-27 10:41:58 -07001196 getFirstActiveWlanIfaceName(), on_alert_callback);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001197 } else {
1198 legacy_status = legacy_hal_.lock()->deregisterErrorAlertCallbackHandler(
Roshan Pius6036c022019-03-27 10:41:58 -07001199 getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -07001200 }
1201 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius203cb032016-12-14 17:41:20 -08001202}
Roshan Pius2c06a3f2016-12-15 17:51:40 -08001203
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -08001204WifiStatus WifiChip::selectTxPowerScenarioInternal(
Jong Wook Kimda830c92018-07-23 15:29:38 -07001205 V1_1::IWifiChip::TxPowerScenario scenario) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001206 auto legacy_status = legacy_hal_.lock()->selectTxPowerScenario(
Roshan Pius6036c022019-03-27 10:41:58 -07001207 getFirstActiveWlanIfaceName(),
Roshan Piusabcf78f2017-10-06 16:30:38 -07001208 hidl_struct_util::convertHidlTxPowerScenarioToLegacy(scenario));
1209 return createWifiStatusFromLegacyError(legacy_status);
Roshan Piusdbd83ef2017-06-20 12:05:40 -07001210}
1211
Roshan Pius735ff432017-07-25 08:48:08 -07001212WifiStatus WifiChip::resetTxPowerScenarioInternal() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001213 auto legacy_status =
Roshan Pius6036c022019-03-27 10:41:58 -07001214 legacy_hal_.lock()->resetTxPowerScenario(getFirstActiveWlanIfaceName());
Roshan Piusabcf78f2017-10-06 16:30:38 -07001215 return createWifiStatusFromLegacyError(legacy_status);
Roshan Piusdbd83ef2017-06-20 12:05:40 -07001216}
1217
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -07001218WifiStatus WifiChip::setLatencyModeInternal(LatencyMode mode) {
1219 auto legacy_status = legacy_hal_.lock()->setLatencyMode(
Roshan Pius6036c022019-03-27 10:41:58 -07001220 getFirstActiveWlanIfaceName(),
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -07001221 hidl_struct_util::convertHidlLatencyModeToLegacy(mode));
1222 return createWifiStatusFromLegacyError(legacy_status);
1223}
1224
Roshan Pius1ce92cf2018-01-22 16:12:19 -08001225WifiStatus WifiChip::registerEventCallbackInternal_1_2(
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -08001226 const sp<V1_2::IWifiChipEventCallback>& /* event_callback */) {
1227 // Deprecated support for this callback.
1228 return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
Roshan Pius1ce92cf2018-01-22 16:12:19 -08001229}
1230
Jong Wook Kimda830c92018-07-23 15:29:38 -07001231WifiStatus WifiChip::selectTxPowerScenarioInternal_1_2(
1232 TxPowerScenario scenario) {
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -08001233 auto legacy_status = legacy_hal_.lock()->selectTxPowerScenario(
Roshan Pius6036c022019-03-27 10:41:58 -07001234 getFirstActiveWlanIfaceName(),
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -08001235 hidl_struct_util::convertHidlTxPowerScenarioToLegacy_1_2(scenario));
1236 return createWifiStatusFromLegacyError(legacy_status);
1237}
1238
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07001239std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal_1_3() {
1240 legacy_hal::wifi_error legacy_status;
1241 uint32_t legacy_feature_set;
1242 uint32_t legacy_logger_feature_set;
1243 const auto ifname = getFirstActiveWlanIfaceName();
1244 std::tie(legacy_status, legacy_feature_set) =
1245 legacy_hal_.lock()->getSupportedFeatureSet(ifname);
1246 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1247 return {createWifiStatusFromLegacyError(legacy_status), 0};
1248 }
1249 std::tie(legacy_status, legacy_logger_feature_set) =
1250 legacy_hal_.lock()->getLoggerSupportedFeatureSet(ifname);
1251 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1252 // some devices don't support querying logger feature set
1253 legacy_logger_feature_set = 0;
1254 }
1255 uint32_t hidl_caps;
1256 if (!hidl_struct_util::convertLegacyFeaturesToHidlChipCapabilities(
1257 legacy_feature_set, legacy_logger_feature_set, &hidl_caps)) {
1258 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), 0};
1259 }
1260 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
1261}
1262
Jimmy Chend460df32019-11-29 17:31:22 +02001263std::pair<WifiStatus, sp<V1_4::IWifiRttController>>
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07001264WifiChip::createRttControllerInternal_1_4(const sp<IWifiIface>& bound_iface) {
1265 if (sta_ifaces_.size() == 0 &&
1266 !canCurrentModeSupportIfaceOfType(IfaceType::STA)) {
1267 LOG(ERROR)
1268 << "createRttControllerInternal_1_4: Chip cannot support STAs "
1269 "(and RTT by extension)";
1270 return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
1271 }
1272 sp<WifiRttController> rtt = new WifiRttController(
1273 getFirstActiveWlanIfaceName(), bound_iface, legacy_hal_);
1274 rtt_controllers_.emplace_back(rtt);
1275 return {createWifiStatus(WifiStatusCode::SUCCESS), rtt};
1276}
1277
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -08001278WifiStatus WifiChip::registerEventCallbackInternal_1_4(
Jimmy Chend460df32019-11-29 17:31:22 +02001279 const sp<V1_4::IWifiChipEventCallback>& event_callback) {
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -08001280 if (!event_cb_handler_.addCallback(event_callback)) {
1281 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
1282 }
1283 return createWifiStatus(WifiStatusCode::SUCCESS);
1284}
1285
Roshan Piusba38d9c2017-12-08 07:32:08 -08001286WifiStatus WifiChip::handleChipConfiguration(
1287 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock,
1288 ChipModeId mode_id) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001289 // If the chip is already configured in a different mode, stop
1290 // the legacy HAL and then start it after firmware mode change.
Roshan Piuscc338202017-11-02 13:54:09 -07001291 if (isValidModeId(current_mode_id_)) {
Roshan Piusba38d9c2017-12-08 07:32:08 -08001292 LOG(INFO) << "Reconfiguring chip from mode " << current_mode_id_
1293 << " to mode " << mode_id;
1294 invalidateAndRemoveAllIfaces();
1295 legacy_hal::wifi_error legacy_status =
1296 legacy_hal_.lock()->stop(lock, []() {});
1297 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1298 LOG(ERROR) << "Failed to stop legacy HAL: "
1299 << legacyErrorToString(legacy_status);
1300 return createWifiStatusFromLegacyError(legacy_status);
1301 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001302 }
Roshan Piuscc338202017-11-02 13:54:09 -07001303 // Firmware mode change not needed for V2 devices.
1304 bool success = true;
Tomasz Wasilczykb424da72018-11-15 11:52:57 -08001305 if (mode_id == feature_flags::chip_mode_ids::kV1Sta) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001306 success = mode_controller_.lock()->changeFirmwareMode(IfaceType::STA);
Tomasz Wasilczykb424da72018-11-15 11:52:57 -08001307 } else if (mode_id == feature_flags::chip_mode_ids::kV1Ap) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001308 success = mode_controller_.lock()->changeFirmwareMode(IfaceType::AP);
1309 }
1310 if (!success) {
1311 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
1312 }
1313 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->start();
1314 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
1315 LOG(ERROR) << "Failed to start legacy HAL: "
1316 << legacyErrorToString(legacy_status);
1317 return createWifiStatusFromLegacyError(legacy_status);
1318 }
Roshan Pius85c64412018-01-22 17:58:40 -08001319 // Every time the HAL is restarted, we need to register the
1320 // radio mode change callback.
1321 WifiStatus status = registerRadioModeChangeCallback();
1322 if (status.code != WifiStatusCode::SUCCESS) {
1323 // This probably is not a critical failure?
1324 LOG(ERROR) << "Failed to register radio mode change callback";
1325 }
chenpaulf5eca292019-03-14 11:08:03 +08001326 // Extract and save the version information into property.
Jimmy Chend460df32019-11-29 17:31:22 +02001327 std::pair<WifiStatus, V1_4::IWifiChip::ChipDebugInfo> version_info;
chenpaulf5eca292019-03-14 11:08:03 +08001328 version_info = WifiChip::requestChipDebugInfoInternal();
1329 if (WifiStatusCode::SUCCESS == version_info.first.code) {
1330 property_set("vendor.wlan.firmware.version",
1331 version_info.second.firmwareDescription.c_str());
1332 property_set("vendor.wlan.driver.version",
1333 version_info.second.driverDescription.c_str());
1334 }
1335
Roshan Piusabcf78f2017-10-06 16:30:38 -07001336 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius2c06a3f2016-12-15 17:51:40 -08001337}
Roshan Pius48185b22016-12-15 19:10:30 -08001338
1339WifiStatus WifiChip::registerDebugRingBufferCallback() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001340 if (debug_ring_buffer_cb_registered_) {
1341 return createWifiStatus(WifiStatusCode::SUCCESS);
Roshan Pius48185b22016-12-15 19:10:30 -08001342 }
Roshan Pius3797e182017-03-30 18:01:54 -07001343
Roshan Piusabcf78f2017-10-06 16:30:38 -07001344 android::wp<WifiChip> weak_ptr_this(this);
1345 const auto& on_ring_buffer_data_callback =
xshu5899e8e2018-01-09 15:36:03 -08001346 [weak_ptr_this](const std::string& name,
Roshan Piusabcf78f2017-10-06 16:30:38 -07001347 const std::vector<uint8_t>& data,
1348 const legacy_hal::wifi_ring_buffer_status& status) {
1349 const auto shared_ptr_this = weak_ptr_this.promote();
1350 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
1351 LOG(ERROR) << "Callback invoked on an invalid object";
1352 return;
1353 }
1354 WifiDebugRingBufferStatus hidl_status;
1355 if (!hidl_struct_util::convertLegacyDebugRingBufferStatusToHidl(
1356 status, &hidl_status)) {
1357 LOG(ERROR) << "Error converting ring buffer status";
1358 return;
1359 }
Veerendranath Jakkam25b3a6f2020-04-14 22:04:39 +05301360 {
1361 std::unique_lock<std::mutex> lk(shared_ptr_this->lock_t);
1362 const auto& target =
1363 shared_ptr_this->ringbuffer_map_.find(name);
1364 if (target != shared_ptr_this->ringbuffer_map_.end()) {
1365 Ringbuffer& cur_buffer = target->second;
1366 cur_buffer.append(data);
1367 } else {
1368 LOG(ERROR) << "Ringname " << name << " not found";
1369 return;
1370 }
xshu0a0fe512020-07-22 17:53:37 -07001371 // unique_lock unlocked here
Roshan Piusabcf78f2017-10-06 16:30:38 -07001372 }
1373 };
1374 legacy_hal::wifi_error legacy_status =
1375 legacy_hal_.lock()->registerRingBufferCallbackHandler(
Roshan Pius6036c022019-03-27 10:41:58 -07001376 getFirstActiveWlanIfaceName(), on_ring_buffer_data_callback);
Roshan Pius48185b22016-12-15 19:10:30 -08001377
Roshan Piusabcf78f2017-10-06 16:30:38 -07001378 if (legacy_status == legacy_hal::WIFI_SUCCESS) {
1379 debug_ring_buffer_cb_registered_ = true;
1380 }
1381 return createWifiStatusFromLegacyError(legacy_status);
Roshan Pius48185b22016-12-15 19:10:30 -08001382}
1383
Roshan Pius85c64412018-01-22 17:58:40 -08001384WifiStatus WifiChip::registerRadioModeChangeCallback() {
1385 android::wp<WifiChip> weak_ptr_this(this);
1386 const auto& on_radio_mode_change_callback =
1387 [weak_ptr_this](const std::vector<legacy_hal::WifiMacInfo>& mac_infos) {
1388 const auto shared_ptr_this = weak_ptr_this.promote();
1389 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
1390 LOG(ERROR) << "Callback invoked on an invalid object";
1391 return;
1392 }
Jimmy Chend460df32019-11-29 17:31:22 +02001393 std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo>
Roshan Pius85c64412018-01-22 17:58:40 -08001394 hidl_radio_mode_infos;
1395 if (!hidl_struct_util::convertLegacyWifiMacInfosToHidl(
1396 mac_infos, &hidl_radio_mode_infos)) {
1397 LOG(ERROR) << "Error converting wifi mac info";
1398 return;
1399 }
1400 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -08001401 if (!callback->onRadioModeChange_1_4(hidl_radio_mode_infos)
Roshan Pius85c64412018-01-22 17:58:40 -08001402 .isOk()) {
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -08001403 LOG(ERROR) << "Failed to invoke onRadioModeChange_1_4"
Roshan Pius85c64412018-01-22 17:58:40 -08001404 << " callback on: " << toString(callback);
1405 }
1406 }
1407 };
1408 legacy_hal::wifi_error legacy_status =
1409 legacy_hal_.lock()->registerRadioModeChangeCallbackHandler(
Roshan Pius6036c022019-03-27 10:41:58 -07001410 getFirstActiveWlanIfaceName(), on_radio_mode_change_callback);
Roshan Pius85c64412018-01-22 17:58:40 -08001411 return createWifiStatusFromLegacyError(legacy_status);
1412}
1413
Jimmy Chend460df32019-11-29 17:31:22 +02001414std::vector<V1_4::IWifiChip::ChipIfaceCombination>
Roshan Piuscc338202017-11-02 13:54:09 -07001415WifiChip::getCurrentModeIfaceCombinations() {
1416 if (!isValidModeId(current_mode_id_)) {
1417 LOG(ERROR) << "Chip not configured in a mode yet";
1418 return {};
1419 }
1420 for (const auto& mode : modes_) {
1421 if (mode.id == current_mode_id_) {
1422 return mode.availableCombinations;
1423 }
1424 }
1425 CHECK(0) << "Expected to find iface combinations for current mode!";
1426 return {};
1427}
1428
1429// Returns a map indexed by IfaceType with the number of ifaces currently
1430// created of the corresponding type.
1431std::map<IfaceType, size_t> WifiChip::getCurrentIfaceCombination() {
1432 std::map<IfaceType, size_t> iface_counts;
1433 iface_counts[IfaceType::AP] = ap_ifaces_.size();
1434 iface_counts[IfaceType::NAN] = nan_ifaces_.size();
1435 iface_counts[IfaceType::P2P] = p2p_ifaces_.size();
1436 iface_counts[IfaceType::STA] = sta_ifaces_.size();
1437 return iface_counts;
1438}
1439
1440// This expands the provided iface combinations to a more parseable
1441// form. Returns a vector of available combinations possible with the number
1442// of ifaces of each type in the combination.
1443// This method is a port of HalDeviceManager.expandIfaceCombos() from framework.
1444std::vector<std::map<IfaceType, size_t>> WifiChip::expandIfaceCombinations(
Jimmy Chend460df32019-11-29 17:31:22 +02001445 const V1_4::IWifiChip::ChipIfaceCombination& combination) {
Roshan Piuscc338202017-11-02 13:54:09 -07001446 uint32_t num_expanded_combos = 1;
1447 for (const auto& limit : combination.limits) {
1448 for (uint32_t i = 0; i < limit.maxIfaces; i++) {
1449 num_expanded_combos *= limit.types.size();
1450 }
1451 }
1452
1453 // Allocate the vector of expanded combos and reset all iface counts to 0
1454 // in each combo.
1455 std::vector<std::map<IfaceType, size_t>> expanded_combos;
1456 expanded_combos.resize(num_expanded_combos);
1457 for (auto& expanded_combo : expanded_combos) {
1458 for (const auto type :
1459 {IfaceType::AP, IfaceType::NAN, IfaceType::P2P, IfaceType::STA}) {
1460 expanded_combo[type] = 0;
1461 }
1462 }
1463 uint32_t span = num_expanded_combos;
1464 for (const auto& limit : combination.limits) {
1465 for (uint32_t i = 0; i < limit.maxIfaces; i++) {
1466 span /= limit.types.size();
1467 for (uint32_t k = 0; k < num_expanded_combos; ++k) {
1468 const auto iface_type =
1469 limit.types[(k / span) % limit.types.size()];
1470 expanded_combos[k][iface_type]++;
1471 }
1472 }
1473 }
1474 return expanded_combos;
1475}
1476
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001477bool WifiChip::canExpandedIfaceComboSupportIfaceOfTypeWithCurrentIfaces(
1478 const std::map<IfaceType, size_t>& expanded_combo,
1479 IfaceType requested_type) {
Roshan Piuscc338202017-11-02 13:54:09 -07001480 const auto current_combo = getCurrentIfaceCombination();
1481
1482 // Check if we have space for 1 more iface of |type| in this combo
1483 for (const auto type :
1484 {IfaceType::AP, IfaceType::NAN, IfaceType::P2P, IfaceType::STA}) {
1485 size_t num_ifaces_needed = current_combo.at(type);
1486 if (type == requested_type) {
1487 num_ifaces_needed++;
1488 }
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001489 size_t num_ifaces_allowed = expanded_combo.at(type);
Roshan Piuscc338202017-11-02 13:54:09 -07001490 if (num_ifaces_needed > num_ifaces_allowed) {
1491 return false;
1492 }
1493 }
1494 return true;
1495}
1496
1497// This method does the following:
1498// a) Enumerate all possible iface combos by expanding the current
1499// ChipIfaceCombination.
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001500// b) Check if the requested iface type can be added to the current mode
1501// with the iface combination that is already active.
1502bool WifiChip::canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(
1503 IfaceType requested_type) {
Roshan Piuscc338202017-11-02 13:54:09 -07001504 if (!isValidModeId(current_mode_id_)) {
1505 LOG(ERROR) << "Chip not configured in a mode yet";
1506 return false;
1507 }
1508 const auto combinations = getCurrentModeIfaceCombinations();
1509 for (const auto& combination : combinations) {
1510 const auto expanded_combos = expandIfaceCombinations(combination);
1511 for (const auto& expanded_combo : expanded_combos) {
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001512 if (canExpandedIfaceComboSupportIfaceOfTypeWithCurrentIfaces(
1513 expanded_combo, requested_type)) {
Roshan Piuscc338202017-11-02 13:54:09 -07001514 return true;
1515 }
1516 }
1517 }
1518 return false;
1519}
1520
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001521// Note: This does not consider ifaces already active. It only checks if the
1522// provided expanded iface combination can support the requested combo.
1523bool WifiChip::canExpandedIfaceComboSupportIfaceCombo(
1524 const std::map<IfaceType, size_t>& expanded_combo,
1525 const std::map<IfaceType, size_t>& req_combo) {
1526 // Check if we have space for 1 more iface of |type| in this combo
1527 for (const auto type :
1528 {IfaceType::AP, IfaceType::NAN, IfaceType::P2P, IfaceType::STA}) {
1529 if (req_combo.count(type) == 0) {
1530 // Iface of "type" not in the req_combo.
1531 continue;
1532 }
1533 size_t num_ifaces_needed = req_combo.at(type);
1534 size_t num_ifaces_allowed = expanded_combo.at(type);
1535 if (num_ifaces_needed > num_ifaces_allowed) {
1536 return false;
1537 }
1538 }
1539 return true;
1540}
1541// This method does the following:
1542// a) Enumerate all possible iface combos by expanding the current
1543// ChipIfaceCombination.
1544// b) Check if the requested iface combo can be added to the current mode.
1545// Note: This does not consider ifaces already active. It only checks if the
1546// current mode can support the requested combo.
1547bool WifiChip::canCurrentModeSupportIfaceCombo(
1548 const std::map<IfaceType, size_t>& req_combo) {
1549 if (!isValidModeId(current_mode_id_)) {
1550 LOG(ERROR) << "Chip not configured in a mode yet";
1551 return false;
1552 }
1553 const auto combinations = getCurrentModeIfaceCombinations();
1554 for (const auto& combination : combinations) {
1555 const auto expanded_combos = expandIfaceCombinations(combination);
1556 for (const auto& expanded_combo : expanded_combos) {
1557 if (canExpandedIfaceComboSupportIfaceCombo(expanded_combo,
1558 req_combo)) {
1559 return true;
1560 }
1561 }
1562 }
1563 return false;
1564}
1565
1566// This method does the following:
1567// a) Enumerate all possible iface combos by expanding the current
1568// ChipIfaceCombination.
1569// b) Check if the requested iface type can be added to the current mode.
1570bool WifiChip::canCurrentModeSupportIfaceOfType(IfaceType requested_type) {
1571 // Check if we can support atleast 1 iface of type.
1572 std::map<IfaceType, size_t> req_iface_combo;
1573 req_iface_combo[requested_type] = 1;
1574 return canCurrentModeSupportIfaceCombo(req_iface_combo);
1575}
1576
Roshan Piuscc338202017-11-02 13:54:09 -07001577bool WifiChip::isValidModeId(ChipModeId mode_id) {
1578 for (const auto& mode : modes_) {
1579 if (mode.id == mode_id) {
1580 return true;
1581 }
1582 }
1583 return false;
1584}
1585
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001586bool WifiChip::isStaApConcurrencyAllowedInCurrentMode() {
1587 // Check if we can support atleast 1 STA & 1 AP concurrently.
1588 std::map<IfaceType, size_t> req_iface_combo;
1589 req_iface_combo[IfaceType::AP] = 1;
1590 req_iface_combo[IfaceType::STA] = 1;
1591 return canCurrentModeSupportIfaceCombo(req_iface_combo);
1592}
1593
James Mattisd2e4c072019-05-22 16:14:48 -07001594bool WifiChip::isDualApAllowedInCurrentMode() {
1595 // Check if we can support atleast 1 STA & 1 AP concurrently.
1596 std::map<IfaceType, size_t> req_iface_combo;
1597 req_iface_combo[IfaceType::AP] = 2;
1598 return canCurrentModeSupportIfaceCombo(req_iface_combo);
1599}
1600
Roshan Pius6036c022019-03-27 10:41:58 -07001601std::string WifiChip::getFirstActiveWlanIfaceName() {
Roshan Pius444473f2019-04-19 08:41:20 -07001602 if (sta_ifaces_.size() > 0) return sta_ifaces_[0]->getName();
1603 if (ap_ifaces_.size() > 0) return ap_ifaces_[0]->getName();
Roshan Pius6036c022019-03-27 10:41:58 -07001604 // This could happen if the chip call is made before any STA/AP
1605 // iface is created. Default to wlan0 for such cases.
Roshan Pius444473f2019-04-19 08:41:20 -07001606 LOG(WARNING) << "No active wlan interfaces in use! Using default";
Jimmy Chen2dddd792019-12-23 17:50:39 +02001607 return getWlanIfaceNameWithType(IfaceType::STA, 0);
Roshan Pius6036c022019-03-27 10:41:58 -07001608}
1609
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001610// Return the first wlan (wlan0, wlan1 etc.) starting from |start_idx|
1611// not already in use.
1612// Note: This doesn't check the actual presence of these interfaces.
Jimmy Chen2dddd792019-12-23 17:50:39 +02001613std::string WifiChip::allocateApOrStaIfaceName(IfaceType type,
1614 uint32_t start_idx) {
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001615 for (unsigned idx = start_idx; idx < kMaxWlanIfaces; idx++) {
Jimmy Chen2dddd792019-12-23 17:50:39 +02001616 const auto ifname = getWlanIfaceNameWithType(type, idx);
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001617 if (findUsingName(ap_ifaces_, ifname)) continue;
1618 if (findUsingName(sta_ifaces_, ifname)) continue;
1619 return ifname;
Roshan Pius8e3c7ef2017-11-03 09:43:08 -07001620 }
1621 // This should never happen. We screwed up somewhere if it did.
Tomasz Wasilczyk77401d32018-12-20 12:42:54 -08001622 CHECK(false) << "All wlan interfaces in use already!";
Roshan Pius8e3c7ef2017-11-03 09:43:08 -07001623 return {};
1624}
1625
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001626// AP iface names start with idx 1 for modes supporting
James Mattisd2e4c072019-05-22 16:14:48 -07001627// concurrent STA and not dual AP, else start with idx 0.
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001628std::string WifiChip::allocateApIfaceName() {
Roshan Pius78cb5992020-04-30 12:39:21 -07001629 // Check if we have a dedicated iface for AP.
1630 std::string ifname = getApIfaceName();
1631 if (!ifname.empty()) {
1632 return ifname;
1633 }
Jimmy Chen2dddd792019-12-23 17:50:39 +02001634 return allocateApOrStaIfaceName(IfaceType::AP,
1635 (isStaApConcurrencyAllowedInCurrentMode() &&
James Mattisd2e4c072019-05-22 16:14:48 -07001636 !isDualApAllowedInCurrentMode())
1637 ? 1
1638 : 0);
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001639}
1640
1641// STA iface names start with idx 0.
1642// Primary STA iface will always be 0.
1643std::string WifiChip::allocateStaIfaceName() {
Jimmy Chen2dddd792019-12-23 17:50:39 +02001644 return allocateApOrStaIfaceName(IfaceType::STA, 0);
Roshan Piusa3e5b7f2019-03-25 13:52:45 -07001645}
1646
xshu5899e8e2018-01-09 15:36:03 -08001647bool WifiChip::writeRingbufferFilesInternal() {
1648 if (!removeOldFilesInternal()) {
1649 LOG(ERROR) << "Error occurred while deleting old tombstone files";
1650 return false;
1651 }
1652 // write ringbuffers to file
Veerendranath Jakkam25b3a6f2020-04-14 22:04:39 +05301653 {
1654 std::unique_lock<std::mutex> lk(lock_t);
1655 for (const auto& item : ringbuffer_map_) {
1656 const Ringbuffer& cur_buffer = item.second;
1657 if (cur_buffer.getData().empty()) {
1658 continue;
1659 }
1660 const std::string file_path_raw =
1661 kTombstoneFolderPath + item.first + "XXXXXXXXXX";
1662 const int dump_fd = mkstemp(makeCharVec(file_path_raw).data());
1663 if (dump_fd == -1) {
1664 PLOG(ERROR) << "create file failed";
1665 return false;
1666 }
1667 unique_fd file_auto_closer(dump_fd);
1668 for (const auto& cur_block : cur_buffer.getData()) {
1669 if (write(dump_fd, cur_block.data(),
1670 sizeof(cur_block[0]) * cur_block.size()) == -1) {
1671 PLOG(ERROR) << "Error writing to file";
1672 }
xshu5899e8e2018-01-09 15:36:03 -08001673 }
1674 }
xshu0a0fe512020-07-22 17:53:37 -07001675 // unique_lock unlocked here
xshu5899e8e2018-01-09 15:36:03 -08001676 }
1677 return true;
1678}
1679
Jimmy Chen2dddd792019-12-23 17:50:39 +02001680std::string WifiChip::getWlanIfaceNameWithType(IfaceType type, unsigned idx) {
1681 std::string ifname;
1682
1683 // let the legacy hal override the interface name
1684 legacy_hal::wifi_error err =
1685 legacy_hal_.lock()->getSupportedIfaceName((uint32_t)type, ifname);
1686 if (err == legacy_hal::WIFI_SUCCESS) return ifname;
1687
1688 return getWlanIfaceName(idx);
1689}
1690
Roshan Pius79a99752016-10-04 13:03:58 -07001691} // namespace implementation
Jimmy Chend460df32019-11-29 17:31:22 +02001692} // namespace V1_5
Roshan Pius3c4e8a32016-10-03 14:53:58 -07001693} // namespace wifi
1694} // namespace hardware
1695} // namespace android