blob: 29123bfe47a64343deeae6806866d3f5ab3f56f2 [file] [log] [blame]
Roshan Piusaabe5752016-09-29 09:03:59 -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
17#include <array>
Roshan Pius155344b2017-08-11 15:47:42 -070018#include <chrono>
Roshan Piusaabe5752016-09-29 09:03:59 -070019
Roshan Piusaabe5752016-09-29 09:03:59 -070020#include <android-base/logging.h>
Ahmed ElArabawy7153e812018-06-05 11:09:39 -070021#include <cutils/properties.h>
Sunil Raviddab4bb2020-02-03 22:45:19 -080022#include <net/if.h>
Roshan Piusaabe5752016-09-29 09:03:59 -070023
Roshan Pius091e1c12017-01-30 16:40:50 -080024#include "hidl_sync_util.h"
Roshan Pius955542e2016-10-28 09:42:44 -070025#include "wifi_legacy_hal.h"
Roshan Piuse73a5062016-12-12 08:53:34 -080026#include "wifi_legacy_hal_stubs.h"
Roshan Pius97334112016-11-18 14:07:54 -080027
Roshan Pius32fc12e2017-01-25 17:44:42 -080028namespace {
Roshan Pius76ff3022016-10-28 10:33:34 -070029// Constants ported over from the legacy HAL calling code
30// (com_android_server_wifi_WifiNative.cpp). This will all be thrown
31// away when this shim layer is replaced by the real vendor
32// implementation.
Roshan Pius511cc492016-10-28 09:54:26 -070033static constexpr uint32_t kMaxVersionStringLength = 256;
Roshan Pius76ff3022016-10-28 10:33:34 -070034static constexpr uint32_t kMaxCachedGscanResults = 64;
35static constexpr uint32_t kMaxGscanFrequenciesForBand = 64;
Roshan Pius7cece412016-10-28 10:38:21 -070036static constexpr uint32_t kLinkLayerStatsDataMpduSizeThreshold = 128;
Roshan Pius8714a3e2016-10-28 10:43:51 -070037static constexpr uint32_t kMaxWakeReasonStatsArraySize = 32;
38static constexpr uint32_t kMaxRingBuffers = 10;
Roshan Pius9bd4e6b2017-09-29 15:04:33 -070039static constexpr uint32_t kMaxStopCompleteWaitMs = 100;
Ahmed ElArabawy7153e812018-06-05 11:09:39 -070040static constexpr char kDriverPropName[] = "wlan.driver.status";
Roshan Pius511cc492016-10-28 09:54:26 -070041
Roshan Pius32fc12e2017-01-25 17:44:42 -080042// Helper function to create a non-const char* for legacy Hal API's.
43std::vector<char> makeCharVec(const std::string& str) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070044 std::vector<char> vec(str.size() + 1);
45 vec.assign(str.begin(), str.end());
46 vec.push_back('\0');
47 return vec;
Roshan Pius32fc12e2017-01-25 17:44:42 -080048}
49} // namespace
50
51namespace android {
52namespace hardware {
53namespace wifi {
Ahmed ElArabawyf501a982019-07-23 15:02:22 -070054namespace V1_4 {
Roshan Pius32fc12e2017-01-25 17:44:42 -080055namespace implementation {
56namespace legacy_hal {
Roshan Piusaabe5752016-09-29 09:03:59 -070057// Legacy HAL functions accept "C" style function pointers, so use global
58// functions to pass to the legacy HAL function and store the corresponding
59// std::function methods to be invoked.
Roshan Pius155344b2017-08-11 15:47:42 -070060//
61// Callback to be invoked once |stop| is complete
Roshan Piusaabe5752016-09-29 09:03:59 -070062std::function<void(wifi_handle handle)> on_stop_complete_internal_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -080063void onAsyncStopComplete(wifi_handle handle) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070064 const auto lock = hidl_sync_util::acquireGlobalLock();
65 if (on_stop_complete_internal_callback) {
66 on_stop_complete_internal_callback(handle);
67 // Invalidate this callback since we don't want this firing again.
68 on_stop_complete_internal_callback = nullptr;
69 }
Roshan Piusaabe5752016-09-29 09:03:59 -070070}
Roshan Piuscdb77f32016-10-03 14:09:57 -070071
72// Callback to be invoked for driver dump.
73std::function<void(char*, int)> on_driver_memory_dump_internal_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -080074void onSyncDriverMemoryDump(char* buffer, int buffer_size) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070075 if (on_driver_memory_dump_internal_callback) {
76 on_driver_memory_dump_internal_callback(buffer, buffer_size);
77 }
Roshan Piuscdb77f32016-10-03 14:09:57 -070078}
79
80// Callback to be invoked for firmware dump.
81std::function<void(char*, int)> on_firmware_memory_dump_internal_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -080082void onSyncFirmwareMemoryDump(char* buffer, int buffer_size) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070083 if (on_firmware_memory_dump_internal_callback) {
84 on_firmware_memory_dump_internal_callback(buffer, buffer_size);
85 }
Roshan Piuscdb77f32016-10-03 14:09:57 -070086}
Roshan Pius76ff3022016-10-28 10:33:34 -070087
88// Callback to be invoked for Gscan events.
89std::function<void(wifi_request_id, wifi_scan_event)>
90 on_gscan_event_internal_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -080091void onAsyncGscanEvent(wifi_request_id id, wifi_scan_event event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070092 const auto lock = hidl_sync_util::acquireGlobalLock();
93 if (on_gscan_event_internal_callback) {
94 on_gscan_event_internal_callback(id, event);
95 }
Roshan Pius76ff3022016-10-28 10:33:34 -070096}
97
98// Callback to be invoked for Gscan full results.
99std::function<void(wifi_request_id, wifi_scan_result*, uint32_t)>
100 on_gscan_full_result_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700101void onAsyncGscanFullResult(wifi_request_id id, wifi_scan_result* result,
Roshan Pius091e1c12017-01-30 16:40:50 -0800102 uint32_t buckets_scanned) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700103 const auto lock = hidl_sync_util::acquireGlobalLock();
104 if (on_gscan_full_result_internal_callback) {
105 on_gscan_full_result_internal_callback(id, result, buckets_scanned);
106 }
Roshan Pius76ff3022016-10-28 10:33:34 -0700107}
108
Roshan Pius7cece412016-10-28 10:38:21 -0700109// Callback to be invoked for link layer stats results.
110std::function<void((wifi_request_id, wifi_iface_stat*, int, wifi_radio_stat*))>
111 on_link_layer_stats_result_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700112void onSyncLinkLayerStatsResult(wifi_request_id id, wifi_iface_stat* iface_stat,
113 int num_radios, wifi_radio_stat* radio_stat) {
114 if (on_link_layer_stats_result_internal_callback) {
115 on_link_layer_stats_result_internal_callback(id, iface_stat, num_radios,
116 radio_stat);
117 }
Roshan Pius7cece412016-10-28 10:38:21 -0700118}
119
Roshan Piusd4767542016-12-06 10:04:05 -0800120// Callback to be invoked for rssi threshold breach.
121std::function<void((wifi_request_id, uint8_t*, int8_t))>
122 on_rssi_threshold_breached_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700123void onAsyncRssiThresholdBreached(wifi_request_id id, uint8_t* bssid,
Roshan Pius091e1c12017-01-30 16:40:50 -0800124 int8_t rssi) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700125 const auto lock = hidl_sync_util::acquireGlobalLock();
126 if (on_rssi_threshold_breached_internal_callback) {
127 on_rssi_threshold_breached_internal_callback(id, bssid, rssi);
128 }
Roshan Piusd4767542016-12-06 10:04:05 -0800129}
130
Roshan Pius8714a3e2016-10-28 10:43:51 -0700131// Callback to be invoked for ring buffer data indication.
132std::function<void(char*, char*, int, wifi_ring_buffer_status*)>
133 on_ring_buffer_data_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700134void onAsyncRingBufferData(char* ring_name, char* buffer, int buffer_size,
Roshan Pius091e1c12017-01-30 16:40:50 -0800135 wifi_ring_buffer_status* status) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700136 const auto lock = hidl_sync_util::acquireGlobalLock();
137 if (on_ring_buffer_data_internal_callback) {
138 on_ring_buffer_data_internal_callback(ring_name, buffer, buffer_size,
139 status);
140 }
Roshan Pius8714a3e2016-10-28 10:43:51 -0700141}
142
Roshan Pius203cb032016-12-14 17:41:20 -0800143// Callback to be invoked for error alert indication.
144std::function<void(wifi_request_id, char*, int, int)>
145 on_error_alert_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700146void onAsyncErrorAlert(wifi_request_id id, char* buffer, int buffer_size,
Roshan Pius091e1c12017-01-30 16:40:50 -0800147 int err_code) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700148 const auto lock = hidl_sync_util::acquireGlobalLock();
149 if (on_error_alert_internal_callback) {
150 on_error_alert_internal_callback(id, buffer, buffer_size, err_code);
151 }
Roshan Pius203cb032016-12-14 17:41:20 -0800152}
153
Roshan Pius01f08772018-01-22 17:56:06 -0800154// Callback to be invoked for radio mode change indication.
155std::function<void(wifi_request_id, uint32_t, wifi_mac_info*)>
156 on_radio_mode_change_internal_callback;
157void onAsyncRadioModeChange(wifi_request_id id, uint32_t num_macs,
158 wifi_mac_info* mac_infos) {
159 const auto lock = hidl_sync_util::acquireGlobalLock();
160 if (on_radio_mode_change_internal_callback) {
161 on_radio_mode_change_internal_callback(id, num_macs, mac_infos);
162 }
163}
164
Roshan Piusd8e915a2016-10-28 11:23:11 -0700165// Callback to be invoked for rtt results results.
Roshan Piusabcf78f2017-10-06 16:30:38 -0700166std::function<void(wifi_request_id, unsigned num_results,
167 wifi_rtt_result* rtt_results[])>
Roshan Piusd8e915a2016-10-28 11:23:11 -0700168 on_rtt_results_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700169void onAsyncRttResults(wifi_request_id id, unsigned num_results,
Roshan Pius091e1c12017-01-30 16:40:50 -0800170 wifi_rtt_result* rtt_results[]) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700171 const auto lock = hidl_sync_util::acquireGlobalLock();
172 if (on_rtt_results_internal_callback) {
173 on_rtt_results_internal_callback(id, num_results, rtt_results);
174 on_rtt_results_internal_callback = nullptr;
175 }
Roshan Piusd8e915a2016-10-28 11:23:11 -0700176}
177
Roshan Pius23012092016-10-28 11:27:40 -0700178// Callbacks for the various NAN operations.
179// NOTE: These have very little conversions to perform before invoking the user
180// callbacks.
181// So, handle all of them here directly to avoid adding an unnecessary layer.
182std::function<void(transaction_id, const NanResponseMsg&)>
183 on_nan_notify_response_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800184void onAysncNanNotifyResponse(transaction_id id, NanResponseMsg* msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700185 const auto lock = hidl_sync_util::acquireGlobalLock();
186 if (on_nan_notify_response_user_callback && msg) {
187 on_nan_notify_response_user_callback(id, *msg);
188 }
Roshan Pius23012092016-10-28 11:27:40 -0700189}
190
Etan Cohen20925b02017-04-04 13:00:14 -0700191std::function<void(const NanPublishRepliedInd&)>
192 on_nan_event_publish_replied_user_callback;
193void onAysncNanEventPublishReplied(NanPublishRepliedInd* /* event */) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700194 LOG(ERROR) << "onAysncNanEventPublishReplied triggered";
Etan Cohen20925b02017-04-04 13:00:14 -0700195}
196
Roshan Pius23012092016-10-28 11:27:40 -0700197std::function<void(const NanPublishTerminatedInd&)>
198 on_nan_event_publish_terminated_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800199void onAysncNanEventPublishTerminated(NanPublishTerminatedInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700200 const auto lock = hidl_sync_util::acquireGlobalLock();
201 if (on_nan_event_publish_terminated_user_callback && event) {
202 on_nan_event_publish_terminated_user_callback(*event);
203 }
Roshan Pius23012092016-10-28 11:27:40 -0700204}
205
206std::function<void(const NanMatchInd&)> on_nan_event_match_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800207void onAysncNanEventMatch(NanMatchInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700208 const auto lock = hidl_sync_util::acquireGlobalLock();
209 if (on_nan_event_match_user_callback && event) {
210 on_nan_event_match_user_callback(*event);
211 }
Roshan Pius23012092016-10-28 11:27:40 -0700212}
213
214std::function<void(const NanMatchExpiredInd&)>
215 on_nan_event_match_expired_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800216void onAysncNanEventMatchExpired(NanMatchExpiredInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700217 const auto lock = hidl_sync_util::acquireGlobalLock();
218 if (on_nan_event_match_expired_user_callback && event) {
219 on_nan_event_match_expired_user_callback(*event);
220 }
Roshan Pius23012092016-10-28 11:27:40 -0700221}
222
223std::function<void(const NanSubscribeTerminatedInd&)>
224 on_nan_event_subscribe_terminated_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800225void onAysncNanEventSubscribeTerminated(NanSubscribeTerminatedInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700226 const auto lock = hidl_sync_util::acquireGlobalLock();
227 if (on_nan_event_subscribe_terminated_user_callback && event) {
228 on_nan_event_subscribe_terminated_user_callback(*event);
229 }
Roshan Pius23012092016-10-28 11:27:40 -0700230}
231
232std::function<void(const NanFollowupInd&)> on_nan_event_followup_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800233void onAysncNanEventFollowup(NanFollowupInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700234 const auto lock = hidl_sync_util::acquireGlobalLock();
235 if (on_nan_event_followup_user_callback && event) {
236 on_nan_event_followup_user_callback(*event);
237 }
Roshan Pius23012092016-10-28 11:27:40 -0700238}
239
240std::function<void(const NanDiscEngEventInd&)>
241 on_nan_event_disc_eng_event_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800242void onAysncNanEventDiscEngEvent(NanDiscEngEventInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700243 const auto lock = hidl_sync_util::acquireGlobalLock();
244 if (on_nan_event_disc_eng_event_user_callback && event) {
245 on_nan_event_disc_eng_event_user_callback(*event);
246 }
Roshan Pius23012092016-10-28 11:27:40 -0700247}
248
249std::function<void(const NanDisabledInd&)> on_nan_event_disabled_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800250void onAysncNanEventDisabled(NanDisabledInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700251 const auto lock = hidl_sync_util::acquireGlobalLock();
252 if (on_nan_event_disabled_user_callback && event) {
253 on_nan_event_disabled_user_callback(*event);
254 }
Roshan Pius23012092016-10-28 11:27:40 -0700255}
256
257std::function<void(const NanTCAInd&)> on_nan_event_tca_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800258void onAysncNanEventTca(NanTCAInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700259 const auto lock = hidl_sync_util::acquireGlobalLock();
260 if (on_nan_event_tca_user_callback && event) {
261 on_nan_event_tca_user_callback(*event);
262 }
Roshan Pius23012092016-10-28 11:27:40 -0700263}
264
265std::function<void(const NanBeaconSdfPayloadInd&)>
266 on_nan_event_beacon_sdf_payload_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800267void onAysncNanEventBeaconSdfPayload(NanBeaconSdfPayloadInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700268 const auto lock = hidl_sync_util::acquireGlobalLock();
269 if (on_nan_event_beacon_sdf_payload_user_callback && event) {
270 on_nan_event_beacon_sdf_payload_user_callback(*event);
271 }
Roshan Pius23012092016-10-28 11:27:40 -0700272}
273
274std::function<void(const NanDataPathRequestInd&)>
275 on_nan_event_data_path_request_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800276void onAysncNanEventDataPathRequest(NanDataPathRequestInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700277 const auto lock = hidl_sync_util::acquireGlobalLock();
278 if (on_nan_event_data_path_request_user_callback && event) {
279 on_nan_event_data_path_request_user_callback(*event);
280 }
Roshan Pius23012092016-10-28 11:27:40 -0700281}
282std::function<void(const NanDataPathConfirmInd&)>
283 on_nan_event_data_path_confirm_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800284void onAysncNanEventDataPathConfirm(NanDataPathConfirmInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700285 const auto lock = hidl_sync_util::acquireGlobalLock();
286 if (on_nan_event_data_path_confirm_user_callback && event) {
287 on_nan_event_data_path_confirm_user_callback(*event);
288 }
Roshan Pius23012092016-10-28 11:27:40 -0700289}
290
291std::function<void(const NanDataPathEndInd&)>
292 on_nan_event_data_path_end_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800293void onAysncNanEventDataPathEnd(NanDataPathEndInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700294 const auto lock = hidl_sync_util::acquireGlobalLock();
295 if (on_nan_event_data_path_end_user_callback && event) {
296 on_nan_event_data_path_end_user_callback(*event);
297 }
Roshan Pius23012092016-10-28 11:27:40 -0700298}
299
300std::function<void(const NanTransmitFollowupInd&)>
301 on_nan_event_transmit_follow_up_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800302void onAysncNanEventTransmitFollowUp(NanTransmitFollowupInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700303 const auto lock = hidl_sync_util::acquireGlobalLock();
304 if (on_nan_event_transmit_follow_up_user_callback && event) {
305 on_nan_event_transmit_follow_up_user_callback(*event);
306 }
Roshan Pius23012092016-10-28 11:27:40 -0700307}
Etan Cohenc190f932017-02-17 13:06:55 -0800308
309std::function<void(const NanRangeRequestInd&)>
310 on_nan_event_range_request_user_callback;
311void onAysncNanEventRangeRequest(NanRangeRequestInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700312 const auto lock = hidl_sync_util::acquireGlobalLock();
313 if (on_nan_event_range_request_user_callback && event) {
314 on_nan_event_range_request_user_callback(*event);
315 }
Etan Cohenc190f932017-02-17 13:06:55 -0800316}
317
318std::function<void(const NanRangeReportInd&)>
319 on_nan_event_range_report_user_callback;
320void onAysncNanEventRangeReport(NanRangeReportInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700321 const auto lock = hidl_sync_util::acquireGlobalLock();
322 if (on_nan_event_range_report_user_callback && event) {
323 on_nan_event_range_report_user_callback(*event);
324 }
Etan Cohenc190f932017-02-17 13:06:55 -0800325}
Etan Cohen1bf15f12017-12-12 16:15:16 -0800326
327std::function<void(const NanDataPathScheduleUpdateInd&)>
328 on_nan_event_schedule_update_user_callback;
329void onAsyncNanEventScheduleUpdate(NanDataPathScheduleUpdateInd* event) {
330 const auto lock = hidl_sync_util::acquireGlobalLock();
331 if (on_nan_event_schedule_update_user_callback && event) {
332 on_nan_event_schedule_update_user_callback(*event);
333 }
334}
Roshan Pius955542e2016-10-28 09:42:44 -0700335// End of the free-standing "C" style callbacks.
Roshan Piusaabe5752016-09-29 09:03:59 -0700336
Roshan Piusc885df02019-05-21 14:49:05 -0700337WifiLegacyHal::WifiLegacyHal(
338 const std::weak_ptr<wifi_system::InterfaceTool> iface_tool)
Roshan Piusaabe5752016-09-29 09:03:59 -0700339 : global_handle_(nullptr),
Roshan Pius11f93032016-12-09 10:26:17 -0800340 awaiting_event_loop_termination_(false),
Roshan Piusc885df02019-05-21 14:49:05 -0700341 is_started_(false),
342 iface_tool_(iface_tool) {}
Roshan Piusaabe5752016-09-29 09:03:59 -0700343
Roshan Pius97334112016-11-18 14:07:54 -0800344wifi_error WifiLegacyHal::initialize() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700345 LOG(DEBUG) << "Initialize legacy HAL";
346 // TODO: Add back the HAL Tool if we need to. All we need from the HAL tool
347 // for now is this function call which we can directly call.
348 if (!initHalFuncTableWithStubs(&global_func_table_)) {
349 LOG(ERROR)
350 << "Failed to initialize legacy hal function table with stubs";
351 return WIFI_ERROR_UNKNOWN;
352 }
353 wifi_error status = init_wifi_vendor_hal_func_table(&global_func_table_);
354 if (status != WIFI_SUCCESS) {
355 LOG(ERROR) << "Failed to initialize legacy hal function table";
356 }
357 return status;
Roshan Pius97334112016-11-18 14:07:54 -0800358}
359
360wifi_error WifiLegacyHal::start() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700361 // Ensure that we're starting in a good state.
362 CHECK(global_func_table_.wifi_initialize && !global_handle_ &&
363 iface_name_to_handle_.empty() && !awaiting_event_loop_termination_);
364 if (is_started_) {
365 LOG(DEBUG) << "Legacy HAL already started";
366 return WIFI_SUCCESS;
367 }
Ahmed ElArabawyc1018152018-03-02 14:35:04 -0800368 LOG(DEBUG) << "Waiting for the driver ready";
369 wifi_error status = global_func_table_.wifi_wait_for_driver_ready();
370 if (status == WIFI_ERROR_TIMED_OUT) {
371 LOG(ERROR) << "Timed out awaiting driver ready";
372 return status;
373 }
Ahmed ElArabawy7153e812018-06-05 11:09:39 -0700374 property_set(kDriverPropName, "ok");
375
Roshan Piusabcf78f2017-10-06 16:30:38 -0700376 LOG(DEBUG) << "Starting legacy HAL";
Roshan Piusc885df02019-05-21 14:49:05 -0700377 if (!iface_tool_.lock()->SetWifiUpState(true)) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700378 LOG(ERROR) << "Failed to set WiFi interface up";
379 return WIFI_ERROR_UNKNOWN;
380 }
Ahmed ElArabawyc1018152018-03-02 14:35:04 -0800381 status = global_func_table_.wifi_initialize(&global_handle_);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700382 if (status != WIFI_SUCCESS || !global_handle_) {
383 LOG(ERROR) << "Failed to retrieve global handle";
384 return status;
385 }
386 std::thread(&WifiLegacyHal::runEventLoop, this).detach();
387 status = retrieveIfaceHandles();
388 if (status != WIFI_SUCCESS || iface_name_to_handle_.empty()) {
389 LOG(ERROR) << "Failed to retrieve wlan interface handle";
390 return status;
391 }
392 LOG(DEBUG) << "Legacy HAL start complete";
393 is_started_ = true;
Roshan Pius11f93032016-12-09 10:26:17 -0800394 return WIFI_SUCCESS;
Roshan Piusaabe5752016-09-29 09:03:59 -0700395}
396
397wifi_error WifiLegacyHal::stop(
Roshan Pius155344b2017-08-11 15:47:42 -0700398 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock,
Roshan Piusaabe5752016-09-29 09:03:59 -0700399 const std::function<void()>& on_stop_complete_user_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700400 if (!is_started_) {
401 LOG(DEBUG) << "Legacy HAL already stopped";
402 on_stop_complete_user_callback();
403 return WIFI_SUCCESS;
404 }
405 LOG(DEBUG) << "Stopping legacy HAL";
406 on_stop_complete_internal_callback = [on_stop_complete_user_callback,
407 this](wifi_handle handle) {
408 CHECK_EQ(global_handle_, handle) << "Handle mismatch";
409 LOG(INFO) << "Legacy HAL stop complete callback received";
410 // Invalidate all the internal pointers now that the HAL is
411 // stopped.
412 invalidate();
Roshan Piusc885df02019-05-21 14:49:05 -0700413 iface_tool_.lock()->SetWifiUpState(false);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700414 on_stop_complete_user_callback();
415 is_started_ = false;
416 };
417 awaiting_event_loop_termination_ = true;
418 global_func_table_.wifi_cleanup(global_handle_, onAsyncStopComplete);
419 const auto status = stop_wait_cv_.wait_for(
420 *lock, std::chrono::milliseconds(kMaxStopCompleteWaitMs),
421 [this] { return !awaiting_event_loop_termination_; });
422 if (!status) {
423 LOG(ERROR) << "Legacy HAL stop failed or timed out";
424 return WIFI_ERROR_UNKNOWN;
425 }
426 LOG(DEBUG) << "Legacy HAL stop complete";
Roshan Pius11f93032016-12-09 10:26:17 -0800427 return WIFI_SUCCESS;
Roshan Piusaabe5752016-09-29 09:03:59 -0700428}
429
Ahmed ElArabawy48229382019-02-07 22:04:53 -0800430bool WifiLegacyHal::isStarted() { return is_started_; }
431
Roshan Piusacededb2017-10-06 14:59:26 -0700432std::pair<wifi_error, std::string> WifiLegacyHal::getDriverVersion(
433 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700434 std::array<char, kMaxVersionStringLength> buffer;
435 buffer.fill(0);
436 wifi_error status = global_func_table_.wifi_get_driver_version(
437 getIfaceHandle(iface_name), buffer.data(), buffer.size());
438 return {status, buffer.data()};
Roshan Pius4b26c832016-10-03 12:49:58 -0700439}
440
Roshan Piusacededb2017-10-06 14:59:26 -0700441std::pair<wifi_error, std::string> WifiLegacyHal::getFirmwareVersion(
442 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700443 std::array<char, kMaxVersionStringLength> buffer;
444 buffer.fill(0);
445 wifi_error status = global_func_table_.wifi_get_firmware_version(
446 getIfaceHandle(iface_name), buffer.data(), buffer.size());
447 return {status, buffer.data()};
Roshan Pius4b26c832016-10-03 12:49:58 -0700448}
449
Roshan Pius3c868522016-10-27 12:43:49 -0700450std::pair<wifi_error, std::vector<uint8_t>>
Roshan Piusabcf78f2017-10-06 16:30:38 -0700451WifiLegacyHal::requestDriverMemoryDump(const std::string& iface_name) {
452 std::vector<uint8_t> driver_dump;
453 on_driver_memory_dump_internal_callback = [&driver_dump](char* buffer,
454 int buffer_size) {
455 driver_dump.insert(driver_dump.end(),
456 reinterpret_cast<uint8_t*>(buffer),
457 reinterpret_cast<uint8_t*>(buffer) + buffer_size);
458 };
459 wifi_error status = global_func_table_.wifi_get_driver_memory_dump(
460 getIfaceHandle(iface_name), {onSyncDriverMemoryDump});
461 on_driver_memory_dump_internal_callback = nullptr;
462 return {status, std::move(driver_dump)};
Roshan Piuscdb77f32016-10-03 14:09:57 -0700463}
464
Roshan Pius3c868522016-10-27 12:43:49 -0700465std::pair<wifi_error, std::vector<uint8_t>>
Roshan Piusacededb2017-10-06 14:59:26 -0700466WifiLegacyHal::requestFirmwareMemoryDump(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700467 std::vector<uint8_t> firmware_dump;
468 on_firmware_memory_dump_internal_callback =
469 [&firmware_dump](char* buffer, int buffer_size) {
470 firmware_dump.insert(
471 firmware_dump.end(), reinterpret_cast<uint8_t*>(buffer),
472 reinterpret_cast<uint8_t*>(buffer) + buffer_size);
473 };
474 wifi_error status = global_func_table_.wifi_get_firmware_memory_dump(
475 getIfaceHandle(iface_name), {onSyncFirmwareMemoryDump});
476 on_firmware_memory_dump_internal_callback = nullptr;
477 return {status, std::move(firmware_dump)};
Roshan Pius0a47c182016-10-28 10:23:00 -0700478}
479
Roshan Piusacededb2017-10-06 14:59:26 -0700480std::pair<wifi_error, uint32_t> WifiLegacyHal::getSupportedFeatureSet(
481 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700482 feature_set set;
Ahmed ElArabawy95e36b72019-11-15 21:24:53 +0000483 static_assert(sizeof(set) == sizeof(uint64_t),
Roshan Pius200a17d2017-11-01 13:03:35 -0700484 "Some feature_flags can not be represented in output");
Roshan Piusabcf78f2017-10-06 16:30:38 -0700485 wifi_error status = global_func_table_.wifi_get_supported_feature_set(
486 getIfaceHandle(iface_name), &set);
487 return {status, static_cast<uint32_t>(set)};
Roshan Pius0a47c182016-10-28 10:23:00 -0700488}
489
490std::pair<wifi_error, PacketFilterCapabilities>
Roshan Piusacededb2017-10-06 14:59:26 -0700491WifiLegacyHal::getPacketFilterCapabilities(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700492 PacketFilterCapabilities caps;
493 wifi_error status = global_func_table_.wifi_get_packet_filter_capabilities(
494 getIfaceHandle(iface_name), &caps.version, &caps.max_len);
495 return {status, caps};
Roshan Pius0a47c182016-10-28 10:23:00 -0700496}
497
Roshan Piusabcf78f2017-10-06 16:30:38 -0700498wifi_error WifiLegacyHal::setPacketFilter(const std::string& iface_name,
499 const std::vector<uint8_t>& program) {
500 return global_func_table_.wifi_set_packet_filter(
501 getIfaceHandle(iface_name), program.data(), program.size());
Roshan Piuscdb77f32016-10-03 14:09:57 -0700502}
503
Bernie Innocenti7e6f71a2018-03-07 00:17:50 +0900504std::pair<wifi_error, std::vector<uint8_t>>
505WifiLegacyHal::readApfPacketFilterData(const std::string& iface_name) {
Bernie Innocenti7e6f71a2018-03-07 00:17:50 +0900506 PacketFilterCapabilities caps;
507 wifi_error status = global_func_table_.wifi_get_packet_filter_capabilities(
508 getIfaceHandle(iface_name), &caps.version, &caps.max_len);
509 if (status != WIFI_SUCCESS) {
510 return {status, {}};
511 }
512
513 // Size the buffer to read the entire program & work memory.
514 std::vector<uint8_t> buffer(caps.max_len);
515
516 status = global_func_table_.wifi_read_packet_filter(
517 getIfaceHandle(iface_name), /*src_offset=*/0, buffer.data(),
518 buffer.size());
519 return {status, move(buffer)};
520}
521
Roshan Pius76ff3022016-10-28 10:33:34 -0700522std::pair<wifi_error, wifi_gscan_capabilities>
Roshan Piusacededb2017-10-06 14:59:26 -0700523WifiLegacyHal::getGscanCapabilities(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700524 wifi_gscan_capabilities caps;
525 wifi_error status = global_func_table_.wifi_get_gscan_capabilities(
526 getIfaceHandle(iface_name), &caps);
527 return {status, caps};
Roshan Pius76ff3022016-10-28 10:33:34 -0700528}
529
530wifi_error WifiLegacyHal::startGscan(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700531 const std::string& iface_name, wifi_request_id id,
Roshan Pius76ff3022016-10-28 10:33:34 -0700532 const wifi_scan_cmd_params& params,
533 const std::function<void(wifi_request_id)>& on_failure_user_callback,
534 const on_gscan_results_callback& on_results_user_callback,
535 const on_gscan_full_result_callback& on_full_result_user_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700536 // If there is already an ongoing background scan, reject new scan requests.
537 if (on_gscan_event_internal_callback ||
538 on_gscan_full_result_internal_callback) {
539 return WIFI_ERROR_NOT_AVAILABLE;
Roshan Pius76ff3022016-10-28 10:33:34 -0700540 }
Roshan Pius76ff3022016-10-28 10:33:34 -0700541
Roshan Piusabcf78f2017-10-06 16:30:38 -0700542 // This callback will be used to either trigger |on_results_user_callback|
543 // or |on_failure_user_callback|.
544 on_gscan_event_internal_callback =
545 [iface_name, on_failure_user_callback, on_results_user_callback, this](
546 wifi_request_id id, wifi_scan_event event) {
547 switch (event) {
548 case WIFI_SCAN_RESULTS_AVAILABLE:
549 case WIFI_SCAN_THRESHOLD_NUM_SCANS:
550 case WIFI_SCAN_THRESHOLD_PERCENT: {
551 wifi_error status;
552 std::vector<wifi_cached_scan_results> cached_scan_results;
553 std::tie(status, cached_scan_results) =
554 getGscanCachedResults(iface_name);
555 if (status == WIFI_SUCCESS) {
556 on_results_user_callback(id, cached_scan_results);
557 return;
558 }
Tomasz Wasilczykb424da72018-11-15 11:52:57 -0800559 FALLTHROUGH_INTENDED;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700560 }
561 // Fall through if failed. Failure to retrieve cached scan
562 // results should trigger a background scan failure.
563 case WIFI_SCAN_FAILED:
564 on_failure_user_callback(id);
565 on_gscan_event_internal_callback = nullptr;
566 on_gscan_full_result_internal_callback = nullptr;
567 return;
568 }
569 LOG(FATAL) << "Unexpected gscan event received: " << event;
570 };
571
572 on_gscan_full_result_internal_callback = [on_full_result_user_callback](
573 wifi_request_id id,
574 wifi_scan_result* result,
575 uint32_t buckets_scanned) {
576 if (result) {
577 on_full_result_user_callback(id, result, buckets_scanned);
578 }
579 };
580
581 wifi_scan_result_handler handler = {onAsyncGscanFullResult,
582 onAsyncGscanEvent};
583 wifi_error status = global_func_table_.wifi_start_gscan(
584 id, getIfaceHandle(iface_name), params, handler);
585 if (status != WIFI_SUCCESS) {
586 on_gscan_event_internal_callback = nullptr;
587 on_gscan_full_result_internal_callback = nullptr;
588 }
589 return status;
Roshan Pius76ff3022016-10-28 10:33:34 -0700590}
591
Roshan Piusabcf78f2017-10-06 16:30:38 -0700592wifi_error WifiLegacyHal::stopGscan(const std::string& iface_name,
593 wifi_request_id id) {
594 // If there is no an ongoing background scan, reject stop requests.
595 // TODO(b/32337212): This needs to be handled by the HIDL object because we
596 // need to return the NOT_STARTED error code.
597 if (!on_gscan_event_internal_callback &&
598 !on_gscan_full_result_internal_callback) {
599 return WIFI_ERROR_NOT_AVAILABLE;
600 }
601 wifi_error status =
602 global_func_table_.wifi_stop_gscan(id, getIfaceHandle(iface_name));
603 // If the request Id is wrong, don't stop the ongoing background scan. Any
604 // other error should be treated as the end of background scan.
605 if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
606 on_gscan_event_internal_callback = nullptr;
607 on_gscan_full_result_internal_callback = nullptr;
608 }
609 return status;
Roshan Pius76ff3022016-10-28 10:33:34 -0700610}
611
612std::pair<wifi_error, std::vector<uint32_t>>
Roshan Piusabcf78f2017-10-06 16:30:38 -0700613WifiLegacyHal::getValidFrequenciesForBand(const std::string& iface_name,
614 wifi_band band) {
615 static_assert(sizeof(uint32_t) >= sizeof(wifi_channel),
616 "Wifi Channel cannot be represented in output");
617 std::vector<uint32_t> freqs;
618 freqs.resize(kMaxGscanFrequenciesForBand);
619 int32_t num_freqs = 0;
620 wifi_error status = global_func_table_.wifi_get_valid_channels(
621 getIfaceHandle(iface_name), band, freqs.size(),
622 reinterpret_cast<wifi_channel*>(freqs.data()), &num_freqs);
623 CHECK(num_freqs >= 0 &&
624 static_cast<uint32_t>(num_freqs) <= kMaxGscanFrequenciesForBand);
625 freqs.resize(num_freqs);
626 return {status, std::move(freqs)};
Roshan Pius76ff3022016-10-28 10:33:34 -0700627}
628
Roshan Piusabcf78f2017-10-06 16:30:38 -0700629wifi_error WifiLegacyHal::setDfsFlag(const std::string& iface_name,
630 bool dfs_on) {
631 return global_func_table_.wifi_set_nodfs_flag(getIfaceHandle(iface_name),
632 dfs_on ? 0 : 1);
Roshan Pius08d1df42017-04-19 23:11:07 -0700633}
634
Roshan Piusabcf78f2017-10-06 16:30:38 -0700635wifi_error WifiLegacyHal::enableLinkLayerStats(const std::string& iface_name,
636 bool debug) {
637 wifi_link_layer_params params;
638 params.mpdu_size_threshold = kLinkLayerStatsDataMpduSizeThreshold;
639 params.aggressive_statistics_gathering = debug;
640 return global_func_table_.wifi_set_link_stats(getIfaceHandle(iface_name),
641 params);
Roshan Pius7cece412016-10-28 10:38:21 -0700642}
643
Roshan Piusacededb2017-10-06 14:59:26 -0700644wifi_error WifiLegacyHal::disableLinkLayerStats(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700645 // TODO: Do we care about these responses?
646 uint32_t clear_mask_rsp;
647 uint8_t stop_rsp;
648 return global_func_table_.wifi_clear_link_stats(
649 getIfaceHandle(iface_name), 0xFFFFFFFF, &clear_mask_rsp, 1, &stop_rsp);
Roshan Pius7cece412016-10-28 10:38:21 -0700650}
651
Roshan Piusacededb2017-10-06 14:59:26 -0700652std::pair<wifi_error, LinkLayerStats> WifiLegacyHal::getLinkLayerStats(
653 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700654 LinkLayerStats link_stats{};
655 LinkLayerStats* link_stats_ptr = &link_stats;
Roshan Pius7cece412016-10-28 10:38:21 -0700656
Roshan Piusabcf78f2017-10-06 16:30:38 -0700657 on_link_layer_stats_result_internal_callback =
658 [&link_stats_ptr](wifi_request_id /* id */,
659 wifi_iface_stat* iface_stats_ptr, int num_radios,
660 wifi_radio_stat* radio_stats_ptr) {
Sunil Ravib0343e72018-11-13 15:52:00 -0800661 wifi_radio_stat* l_radio_stats_ptr;
662
Roshan Piusabcf78f2017-10-06 16:30:38 -0700663 if (iface_stats_ptr != nullptr) {
664 link_stats_ptr->iface = *iface_stats_ptr;
665 link_stats_ptr->iface.num_peers = 0;
666 } else {
667 LOG(ERROR) << "Invalid iface stats in link layer stats";
668 }
669 if (num_radios <= 0 || radio_stats_ptr == nullptr) {
670 LOG(ERROR) << "Invalid radio stats in link layer stats";
671 return;
672 }
Sunil Ravib0343e72018-11-13 15:52:00 -0800673 l_radio_stats_ptr = radio_stats_ptr;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700674 for (int i = 0; i < num_radios; i++) {
675 LinkLayerRadioStats radio;
Sunil Ravib0343e72018-11-13 15:52:00 -0800676
677 radio.stats = *l_radio_stats_ptr;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700678 // Copy over the tx level array to the separate vector.
Sunil Ravib0343e72018-11-13 15:52:00 -0800679 if (l_radio_stats_ptr->num_tx_levels > 0 &&
680 l_radio_stats_ptr->tx_time_per_levels != nullptr) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700681 radio.tx_time_per_levels.assign(
Sunil Ravib0343e72018-11-13 15:52:00 -0800682 l_radio_stats_ptr->tx_time_per_levels,
683 l_radio_stats_ptr->tx_time_per_levels +
684 l_radio_stats_ptr->num_tx_levels);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700685 }
686 radio.stats.num_tx_levels = 0;
687 radio.stats.tx_time_per_levels = nullptr;
Sunil Ravib0343e72018-11-13 15:52:00 -0800688 /* Copy over the channel stat to separate vector */
689 if (l_radio_stats_ptr->num_channels > 0) {
690 /* Copy the channel stats */
691 radio.channel_stats.assign(
692 l_radio_stats_ptr->channels,
693 l_radio_stats_ptr->channels +
694 l_radio_stats_ptr->num_channels);
695 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700696 link_stats_ptr->radios.push_back(radio);
Sunil Ravib0343e72018-11-13 15:52:00 -0800697 l_radio_stats_ptr =
698 (wifi_radio_stat*)((u8*)l_radio_stats_ptr +
699 sizeof(wifi_radio_stat) +
700 (sizeof(wifi_channel_stat) *
701 l_radio_stats_ptr->num_channels));
Roshan Piusabcf78f2017-10-06 16:30:38 -0700702 }
703 };
Roshan Pius7cece412016-10-28 10:38:21 -0700704
Roshan Piusabcf78f2017-10-06 16:30:38 -0700705 wifi_error status = global_func_table_.wifi_get_link_stats(
706 0, getIfaceHandle(iface_name), {onSyncLinkLayerStatsResult});
707 on_link_layer_stats_result_internal_callback = nullptr;
708 return {status, link_stats};
Roshan Pius7cece412016-10-28 10:38:21 -0700709}
710
Roshan Piusd4767542016-12-06 10:04:05 -0800711wifi_error WifiLegacyHal::startRssiMonitoring(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700712 const std::string& iface_name, wifi_request_id id, int8_t max_rssi,
Roshan Piusd4767542016-12-06 10:04:05 -0800713 int8_t min_rssi,
714 const on_rssi_threshold_breached_callback&
715 on_threshold_breached_user_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700716 if (on_rssi_threshold_breached_internal_callback) {
717 return WIFI_ERROR_NOT_AVAILABLE;
718 }
719 on_rssi_threshold_breached_internal_callback =
720 [on_threshold_breached_user_callback](wifi_request_id id,
721 uint8_t* bssid_ptr, int8_t rssi) {
722 if (!bssid_ptr) {
723 return;
724 }
725 std::array<uint8_t, 6> bssid_arr;
726 // |bssid_ptr| pointer is assumed to have 6 bytes for the mac
727 // address.
728 std::copy(bssid_ptr, bssid_ptr + 6, std::begin(bssid_arr));
729 on_threshold_breached_user_callback(id, bssid_arr, rssi);
730 };
731 wifi_error status = global_func_table_.wifi_start_rssi_monitoring(
732 id, getIfaceHandle(iface_name), max_rssi, min_rssi,
733 {onAsyncRssiThresholdBreached});
734 if (status != WIFI_SUCCESS) {
735 on_rssi_threshold_breached_internal_callback = nullptr;
736 }
737 return status;
Roshan Piusd4767542016-12-06 10:04:05 -0800738}
739
Roshan Piusabcf78f2017-10-06 16:30:38 -0700740wifi_error WifiLegacyHal::stopRssiMonitoring(const std::string& iface_name,
741 wifi_request_id id) {
742 if (!on_rssi_threshold_breached_internal_callback) {
743 return WIFI_ERROR_NOT_AVAILABLE;
744 }
745 wifi_error status = global_func_table_.wifi_stop_rssi_monitoring(
746 id, getIfaceHandle(iface_name));
747 // If the request Id is wrong, don't stop the ongoing rssi monitoring. Any
748 // other error should be treated as the end of background scan.
749 if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
750 on_rssi_threshold_breached_internal_callback = nullptr;
751 }
752 return status;
Roshan Piusd4767542016-12-06 10:04:05 -0800753}
754
Roshan Pius26801cb2016-12-13 14:25:45 -0800755std::pair<wifi_error, wifi_roaming_capabilities>
Roshan Piusacededb2017-10-06 14:59:26 -0700756WifiLegacyHal::getRoamingCapabilities(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700757 wifi_roaming_capabilities caps;
758 wifi_error status = global_func_table_.wifi_get_roaming_capabilities(
759 getIfaceHandle(iface_name), &caps);
760 return {status, caps};
Roshan Pius26801cb2016-12-13 14:25:45 -0800761}
762
Roshan Piusabcf78f2017-10-06 16:30:38 -0700763wifi_error WifiLegacyHal::configureRoaming(const std::string& iface_name,
764 const wifi_roaming_config& config) {
765 wifi_roaming_config config_internal = config;
766 return global_func_table_.wifi_configure_roaming(getIfaceHandle(iface_name),
767 &config_internal);
Roshan Piusaf727c02017-01-11 15:37:25 -0800768}
769
Roshan Piusabcf78f2017-10-06 16:30:38 -0700770wifi_error WifiLegacyHal::enableFirmwareRoaming(const std::string& iface_name,
771 fw_roaming_state_t state) {
772 return global_func_table_.wifi_enable_firmware_roaming(
773 getIfaceHandle(iface_name), state);
Roshan Pius26801cb2016-12-13 14:25:45 -0800774}
775
Roshan Piusabcf78f2017-10-06 16:30:38 -0700776wifi_error WifiLegacyHal::configureNdOffload(const std::string& iface_name,
777 bool enable) {
778 return global_func_table_.wifi_configure_nd_offload(
779 getIfaceHandle(iface_name), enable);
Roshan Pius26801cb2016-12-13 14:25:45 -0800780}
781
Roshan Pius9a9869a2017-01-11 16:42:16 -0800782wifi_error WifiLegacyHal::startSendingOffloadedPacket(
Ahmed ElArabawyffbad182019-03-05 17:38:06 -0800783 const std::string& iface_name, uint32_t cmd_id, uint16_t ether_type,
Roshan Pius9a9869a2017-01-11 16:42:16 -0800784 const std::vector<uint8_t>& ip_packet_data,
785 const std::array<uint8_t, 6>& src_address,
Roshan Piusabcf78f2017-10-06 16:30:38 -0700786 const std::array<uint8_t, 6>& dst_address, uint32_t period_in_ms) {
787 std::vector<uint8_t> ip_packet_data_internal(ip_packet_data);
788 std::vector<uint8_t> src_address_internal(
789 src_address.data(), src_address.data() + src_address.size());
790 std::vector<uint8_t> dst_address_internal(
791 dst_address.data(), dst_address.data() + dst_address.size());
792 return global_func_table_.wifi_start_sending_offloaded_packet(
Ahmed ElArabawyffbad182019-03-05 17:38:06 -0800793 cmd_id, getIfaceHandle(iface_name), ether_type,
794 ip_packet_data_internal.data(), ip_packet_data_internal.size(),
795 src_address_internal.data(), dst_address_internal.data(), period_in_ms);
Roshan Pius9a9869a2017-01-11 16:42:16 -0800796}
797
Roshan Piusacededb2017-10-06 14:59:26 -0700798wifi_error WifiLegacyHal::stopSendingOffloadedPacket(
799 const std::string& iface_name, uint32_t cmd_id) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700800 return global_func_table_.wifi_stop_sending_offloaded_packet(
801 cmd_id, getIfaceHandle(iface_name));
Roshan Pius9a9869a2017-01-11 16:42:16 -0800802}
803
Roshan Piusabcf78f2017-10-06 16:30:38 -0700804wifi_error WifiLegacyHal::selectTxPowerScenario(const std::string& iface_name,
805 wifi_power_scenario scenario) {
806 return global_func_table_.wifi_select_tx_power_scenario(
807 getIfaceHandle(iface_name), scenario);
Roshan Pius8184d212017-07-11 08:59:29 -0700808}
809
Roshan Piusacededb2017-10-06 14:59:26 -0700810wifi_error WifiLegacyHal::resetTxPowerScenario(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700811 return global_func_table_.wifi_reset_tx_power_scenario(
812 getIfaceHandle(iface_name));
Roshan Pius8184d212017-07-11 08:59:29 -0700813}
814
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700815wifi_error WifiLegacyHal::setLatencyMode(const std::string& iface_name,
816 wifi_latency_mode mode) {
817 return global_func_table_.wifi_set_latency_mode(getIfaceHandle(iface_name),
818 mode);
819}
820
Kumar Anandf2747e02020-01-10 16:49:13 -0800821wifi_error WifiLegacyHal::setThermalMitigationMode(wifi_thermal_mode mode,
822 uint32_t completion_window) {
Kumar Anand913d5602019-12-18 16:02:37 -0800823 return global_func_table_.wifi_set_thermal_mitigation_mode(
Kumar Anandf2747e02020-01-10 16:49:13 -0800824 global_handle_, mode, completion_window);
Kumar Anand913d5602019-12-18 16:02:37 -0800825}
826
Ahmed ElArabawya1d13652020-01-29 09:22:28 -0800827wifi_error WifiLegacyHal::setDscpToAccessCategoryMapping(
828 uint32_t start, uint32_t end, uint32_t access_category) {
829 return global_func_table_.wifi_map_dscp_access_category(
830 global_handle_, start, end, access_category);
831}
832
833wifi_error WifiLegacyHal::resetDscpToAccessCategoryMapping() {
834 return global_func_table_.wifi_reset_dscp_mapping(global_handle_);
835}
836
Roshan Piusacededb2017-10-06 14:59:26 -0700837std::pair<wifi_error, uint32_t> WifiLegacyHal::getLoggerSupportedFeatureSet(
838 const std::string& iface_name) {
Roshan Pius200a17d2017-11-01 13:03:35 -0700839 uint32_t supported_feature_flags;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700840 wifi_error status =
841 global_func_table_.wifi_get_logger_supported_feature_set(
Roshan Pius200a17d2017-11-01 13:03:35 -0700842 getIfaceHandle(iface_name), &supported_feature_flags);
843 return {status, supported_feature_flags};
Roshan Pius8714a3e2016-10-28 10:43:51 -0700844}
845
Roshan Piusacededb2017-10-06 14:59:26 -0700846wifi_error WifiLegacyHal::startPktFateMonitoring(
847 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700848 return global_func_table_.wifi_start_pkt_fate_monitoring(
849 getIfaceHandle(iface_name));
Roshan Pius8714a3e2016-10-28 10:43:51 -0700850}
851
Roshan Piusabcf78f2017-10-06 16:30:38 -0700852std::pair<wifi_error, std::vector<wifi_tx_report>> WifiLegacyHal::getTxPktFates(
853 const std::string& iface_name) {
854 std::vector<wifi_tx_report> tx_pkt_fates;
855 tx_pkt_fates.resize(MAX_FATE_LOG_LEN);
856 size_t num_fates = 0;
857 wifi_error status = global_func_table_.wifi_get_tx_pkt_fates(
858 getIfaceHandle(iface_name), tx_pkt_fates.data(), tx_pkt_fates.size(),
859 &num_fates);
860 CHECK(num_fates <= MAX_FATE_LOG_LEN);
861 tx_pkt_fates.resize(num_fates);
862 return {status, std::move(tx_pkt_fates)};
Roshan Pius8714a3e2016-10-28 10:43:51 -0700863}
864
Roshan Piusabcf78f2017-10-06 16:30:38 -0700865std::pair<wifi_error, std::vector<wifi_rx_report>> WifiLegacyHal::getRxPktFates(
866 const std::string& iface_name) {
867 std::vector<wifi_rx_report> rx_pkt_fates;
868 rx_pkt_fates.resize(MAX_FATE_LOG_LEN);
869 size_t num_fates = 0;
870 wifi_error status = global_func_table_.wifi_get_rx_pkt_fates(
871 getIfaceHandle(iface_name), rx_pkt_fates.data(), rx_pkt_fates.size(),
872 &num_fates);
873 CHECK(num_fates <= MAX_FATE_LOG_LEN);
874 rx_pkt_fates.resize(num_fates);
875 return {status, std::move(rx_pkt_fates)};
Roshan Pius8714a3e2016-10-28 10:43:51 -0700876}
877
Roshan Piusacededb2017-10-06 14:59:26 -0700878std::pair<wifi_error, WakeReasonStats> WifiLegacyHal::getWakeReasonStats(
879 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700880 WakeReasonStats stats;
881 stats.cmd_event_wake_cnt.resize(kMaxWakeReasonStatsArraySize);
882 stats.driver_fw_local_wake_cnt.resize(kMaxWakeReasonStatsArraySize);
Roshan Pius8714a3e2016-10-28 10:43:51 -0700883
Roshan Piusabcf78f2017-10-06 16:30:38 -0700884 // This legacy struct needs separate memory to store the variable sized wake
885 // reason types.
886 stats.wake_reason_cnt.cmd_event_wake_cnt =
887 reinterpret_cast<int32_t*>(stats.cmd_event_wake_cnt.data());
888 stats.wake_reason_cnt.cmd_event_wake_cnt_sz =
889 stats.cmd_event_wake_cnt.size();
890 stats.wake_reason_cnt.cmd_event_wake_cnt_used = 0;
891 stats.wake_reason_cnt.driver_fw_local_wake_cnt =
892 reinterpret_cast<int32_t*>(stats.driver_fw_local_wake_cnt.data());
893 stats.wake_reason_cnt.driver_fw_local_wake_cnt_sz =
894 stats.driver_fw_local_wake_cnt.size();
895 stats.wake_reason_cnt.driver_fw_local_wake_cnt_used = 0;
Roshan Pius8714a3e2016-10-28 10:43:51 -0700896
Roshan Piusabcf78f2017-10-06 16:30:38 -0700897 wifi_error status = global_func_table_.wifi_get_wake_reason_stats(
898 getIfaceHandle(iface_name), &stats.wake_reason_cnt);
Roshan Pius8714a3e2016-10-28 10:43:51 -0700899
Roshan Piusabcf78f2017-10-06 16:30:38 -0700900 CHECK(
901 stats.wake_reason_cnt.cmd_event_wake_cnt_used >= 0 &&
Roshan Pius8714a3e2016-10-28 10:43:51 -0700902 static_cast<uint32_t>(stats.wake_reason_cnt.cmd_event_wake_cnt_used) <=
903 kMaxWakeReasonStatsArraySize);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700904 stats.cmd_event_wake_cnt.resize(
905 stats.wake_reason_cnt.cmd_event_wake_cnt_used);
906 stats.wake_reason_cnt.cmd_event_wake_cnt = nullptr;
Roshan Pius8714a3e2016-10-28 10:43:51 -0700907
Roshan Piusabcf78f2017-10-06 16:30:38 -0700908 CHECK(stats.wake_reason_cnt.driver_fw_local_wake_cnt_used >= 0 &&
909 static_cast<uint32_t>(
910 stats.wake_reason_cnt.driver_fw_local_wake_cnt_used) <=
911 kMaxWakeReasonStatsArraySize);
912 stats.driver_fw_local_wake_cnt.resize(
913 stats.wake_reason_cnt.driver_fw_local_wake_cnt_used);
914 stats.wake_reason_cnt.driver_fw_local_wake_cnt = nullptr;
Roshan Pius8714a3e2016-10-28 10:43:51 -0700915
Roshan Piusabcf78f2017-10-06 16:30:38 -0700916 return {status, stats};
Roshan Pius8714a3e2016-10-28 10:43:51 -0700917}
918
919wifi_error WifiLegacyHal::registerRingBufferCallbackHandler(
Roshan Piusacededb2017-10-06 14:59:26 -0700920 const std::string& iface_name,
Roshan Pius8714a3e2016-10-28 10:43:51 -0700921 const on_ring_buffer_data_callback& on_user_data_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700922 if (on_ring_buffer_data_internal_callback) {
923 return WIFI_ERROR_NOT_AVAILABLE;
Roshan Pius8714a3e2016-10-28 10:43:51 -0700924 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700925 on_ring_buffer_data_internal_callback =
926 [on_user_data_callback](char* ring_name, char* buffer, int buffer_size,
927 wifi_ring_buffer_status* status) {
928 if (status && buffer) {
929 std::vector<uint8_t> buffer_vector(
930 reinterpret_cast<uint8_t*>(buffer),
931 reinterpret_cast<uint8_t*>(buffer) + buffer_size);
932 on_user_data_callback(ring_name, buffer_vector, *status);
933 }
934 };
935 wifi_error status = global_func_table_.wifi_set_log_handler(
936 0, getIfaceHandle(iface_name), {onAsyncRingBufferData});
937 if (status != WIFI_SUCCESS) {
938 on_ring_buffer_data_internal_callback = nullptr;
939 }
940 return status;
Roshan Piusadc87cb2016-12-14 18:02:56 -0800941}
942
Roshan Piusacededb2017-10-06 14:59:26 -0700943wifi_error WifiLegacyHal::deregisterRingBufferCallbackHandler(
944 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700945 if (!on_ring_buffer_data_internal_callback) {
946 return WIFI_ERROR_NOT_AVAILABLE;
947 }
948 on_ring_buffer_data_internal_callback = nullptr;
949 return global_func_table_.wifi_reset_log_handler(
950 0, getIfaceHandle(iface_name));
Roshan Pius8714a3e2016-10-28 10:43:51 -0700951}
952
953std::pair<wifi_error, std::vector<wifi_ring_buffer_status>>
Roshan Piusacededb2017-10-06 14:59:26 -0700954WifiLegacyHal::getRingBuffersStatus(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700955 std::vector<wifi_ring_buffer_status> ring_buffers_status;
956 ring_buffers_status.resize(kMaxRingBuffers);
957 uint32_t num_rings = kMaxRingBuffers;
958 wifi_error status = global_func_table_.wifi_get_ring_buffers_status(
959 getIfaceHandle(iface_name), &num_rings, ring_buffers_status.data());
960 CHECK(num_rings <= kMaxRingBuffers);
961 ring_buffers_status.resize(num_rings);
962 return {status, std::move(ring_buffers_status)};
Roshan Pius8714a3e2016-10-28 10:43:51 -0700963}
964
Roshan Piusabcf78f2017-10-06 16:30:38 -0700965wifi_error WifiLegacyHal::startRingBufferLogging(const std::string& iface_name,
966 const std::string& ring_name,
967 uint32_t verbose_level,
968 uint32_t max_interval_sec,
969 uint32_t min_data_size) {
970 return global_func_table_.wifi_start_logging(
971 getIfaceHandle(iface_name), verbose_level, 0, max_interval_sec,
972 min_data_size, makeCharVec(ring_name).data());
Roshan Pius8714a3e2016-10-28 10:43:51 -0700973}
974
Roshan Piusabcf78f2017-10-06 16:30:38 -0700975wifi_error WifiLegacyHal::getRingBufferData(const std::string& iface_name,
976 const std::string& ring_name) {
977 return global_func_table_.wifi_get_ring_data(getIfaceHandle(iface_name),
978 makeCharVec(ring_name).data());
Roshan Pius8714a3e2016-10-28 10:43:51 -0700979}
980
Roshan Pius203cb032016-12-14 17:41:20 -0800981wifi_error WifiLegacyHal::registerErrorAlertCallbackHandler(
Roshan Piusacededb2017-10-06 14:59:26 -0700982 const std::string& iface_name,
Roshan Pius203cb032016-12-14 17:41:20 -0800983 const on_error_alert_callback& on_user_alert_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700984 if (on_error_alert_internal_callback) {
985 return WIFI_ERROR_NOT_AVAILABLE;
Roshan Pius203cb032016-12-14 17:41:20 -0800986 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700987 on_error_alert_internal_callback = [on_user_alert_callback](
988 wifi_request_id id, char* buffer,
989 int buffer_size, int err_code) {
990 if (buffer) {
991 CHECK(id == 0);
992 on_user_alert_callback(
993 err_code,
994 std::vector<uint8_t>(
995 reinterpret_cast<uint8_t*>(buffer),
996 reinterpret_cast<uint8_t*>(buffer) + buffer_size));
997 }
998 };
999 wifi_error status = global_func_table_.wifi_set_alert_handler(
1000 0, getIfaceHandle(iface_name), {onAsyncErrorAlert});
1001 if (status != WIFI_SUCCESS) {
1002 on_error_alert_internal_callback = nullptr;
1003 }
1004 return status;
Roshan Pius203cb032016-12-14 17:41:20 -08001005}
1006
Roshan Piusacededb2017-10-06 14:59:26 -07001007wifi_error WifiLegacyHal::deregisterErrorAlertCallbackHandler(
1008 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001009 if (!on_error_alert_internal_callback) {
1010 return WIFI_ERROR_NOT_AVAILABLE;
1011 }
1012 on_error_alert_internal_callback = nullptr;
1013 return global_func_table_.wifi_reset_alert_handler(
1014 0, getIfaceHandle(iface_name));
Roshan Pius203cb032016-12-14 17:41:20 -08001015}
1016
Roshan Pius01f08772018-01-22 17:56:06 -08001017wifi_error WifiLegacyHal::registerRadioModeChangeCallbackHandler(
1018 const std::string& iface_name,
1019 const on_radio_mode_change_callback& on_user_change_callback) {
1020 if (on_radio_mode_change_internal_callback) {
1021 return WIFI_ERROR_NOT_AVAILABLE;
1022 }
1023 on_radio_mode_change_internal_callback = [on_user_change_callback](
1024 wifi_request_id /* id */,
1025 uint32_t num_macs,
1026 wifi_mac_info* mac_infos_arr) {
1027 if (num_macs > 0 && mac_infos_arr) {
1028 std::vector<WifiMacInfo> mac_infos_vec;
1029 for (uint32_t i = 0; i < num_macs; i++) {
1030 WifiMacInfo mac_info;
1031 mac_info.wlan_mac_id = mac_infos_arr[i].wlan_mac_id;
1032 mac_info.mac_band = mac_infos_arr[i].mac_band;
1033 for (int32_t j = 0; j < mac_infos_arr[i].num_iface; j++) {
1034 WifiIfaceInfo iface_info;
1035 iface_info.name = mac_infos_arr[i].iface_info[j].iface_name;
1036 iface_info.channel = mac_infos_arr[i].iface_info[j].channel;
1037 mac_info.iface_infos.push_back(iface_info);
1038 }
1039 mac_infos_vec.push_back(mac_info);
1040 }
1041 on_user_change_callback(mac_infos_vec);
1042 }
1043 };
1044 wifi_error status = global_func_table_.wifi_set_radio_mode_change_handler(
1045 0, getIfaceHandle(iface_name), {onAsyncRadioModeChange});
1046 if (status != WIFI_SUCCESS) {
1047 on_radio_mode_change_internal_callback = nullptr;
1048 }
1049 return status;
1050}
1051
Roshan Piusd8e915a2016-10-28 11:23:11 -07001052wifi_error WifiLegacyHal::startRttRangeRequest(
Roshan Piusabcf78f2017-10-06 16:30:38 -07001053 const std::string& iface_name, wifi_request_id id,
Roshan Piusd8e915a2016-10-28 11:23:11 -07001054 const std::vector<wifi_rtt_config>& rtt_configs,
1055 const on_rtt_results_callback& on_results_user_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001056 if (on_rtt_results_internal_callback) {
1057 return WIFI_ERROR_NOT_AVAILABLE;
Roshan Piusd8e915a2016-10-28 11:23:11 -07001058 }
Roshan Piusd8e915a2016-10-28 11:23:11 -07001059
Roshan Piusabcf78f2017-10-06 16:30:38 -07001060 on_rtt_results_internal_callback =
1061 [on_results_user_callback](wifi_request_id id, unsigned num_results,
1062 wifi_rtt_result* rtt_results[]) {
1063 if (num_results > 0 && !rtt_results) {
1064 LOG(ERROR) << "Unexpected nullptr in RTT results";
1065 return;
1066 }
1067 std::vector<const wifi_rtt_result*> rtt_results_vec;
1068 std::copy_if(rtt_results, rtt_results + num_results,
1069 back_inserter(rtt_results_vec),
1070 [](wifi_rtt_result* rtt_result) {
1071 return rtt_result != nullptr;
1072 });
1073 on_results_user_callback(id, rtt_results_vec);
1074 };
1075
1076 std::vector<wifi_rtt_config> rtt_configs_internal(rtt_configs);
1077 wifi_error status = global_func_table_.wifi_rtt_range_request(
1078 id, getIfaceHandle(iface_name), rtt_configs.size(),
1079 rtt_configs_internal.data(), {onAsyncRttResults});
1080 if (status != WIFI_SUCCESS) {
1081 on_rtt_results_internal_callback = nullptr;
1082 }
1083 return status;
Roshan Piusd8e915a2016-10-28 11:23:11 -07001084}
1085
1086wifi_error WifiLegacyHal::cancelRttRangeRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001087 const std::string& iface_name, wifi_request_id id,
1088 const std::vector<std::array<uint8_t, 6>>& mac_addrs) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001089 if (!on_rtt_results_internal_callback) {
1090 return WIFI_ERROR_NOT_AVAILABLE;
1091 }
1092 static_assert(sizeof(mac_addr) == sizeof(std::array<uint8_t, 6>),
1093 "MAC address size mismatch");
1094 // TODO: How do we handle partial cancels (i.e only a subset of enabled mac
1095 // addressed are cancelled).
1096 std::vector<std::array<uint8_t, 6>> mac_addrs_internal(mac_addrs);
1097 wifi_error status = global_func_table_.wifi_rtt_range_cancel(
1098 id, getIfaceHandle(iface_name), mac_addrs.size(),
1099 reinterpret_cast<mac_addr*>(mac_addrs_internal.data()));
1100 // If the request Id is wrong, don't stop the ongoing range request. Any
1101 // other error should be treated as the end of rtt ranging.
1102 if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
1103 on_rtt_results_internal_callback = nullptr;
1104 }
1105 return status;
Roshan Piusd8e915a2016-10-28 11:23:11 -07001106}
1107
Roshan Piusabcf78f2017-10-06 16:30:38 -07001108std::pair<wifi_error, wifi_rtt_capabilities> WifiLegacyHal::getRttCapabilities(
1109 const std::string& iface_name) {
1110 wifi_rtt_capabilities rtt_caps;
1111 wifi_error status = global_func_table_.wifi_get_rtt_capabilities(
1112 getIfaceHandle(iface_name), &rtt_caps);
1113 return {status, rtt_caps};
Roshan Piusd8e915a2016-10-28 11:23:11 -07001114}
1115
Roshan Piusacededb2017-10-06 14:59:26 -07001116std::pair<wifi_error, wifi_rtt_responder> WifiLegacyHal::getRttResponderInfo(
1117 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001118 wifi_rtt_responder rtt_responder;
1119 wifi_error status = global_func_table_.wifi_rtt_get_responder_info(
1120 getIfaceHandle(iface_name), &rtt_responder);
1121 return {status, rtt_responder};
Roshan Piusd8e915a2016-10-28 11:23:11 -07001122}
1123
1124wifi_error WifiLegacyHal::enableRttResponder(
Roshan Piusabcf78f2017-10-06 16:30:38 -07001125 const std::string& iface_name, wifi_request_id id,
1126 const wifi_channel_info& channel_hint, uint32_t max_duration_secs,
Roshan Piusd8e915a2016-10-28 11:23:11 -07001127 const wifi_rtt_responder& info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001128 wifi_rtt_responder info_internal(info);
1129 return global_func_table_.wifi_enable_responder(
1130 id, getIfaceHandle(iface_name), channel_hint, max_duration_secs,
1131 &info_internal);
Roshan Piusd8e915a2016-10-28 11:23:11 -07001132}
1133
Roshan Piusabcf78f2017-10-06 16:30:38 -07001134wifi_error WifiLegacyHal::disableRttResponder(const std::string& iface_name,
1135 wifi_request_id id) {
1136 return global_func_table_.wifi_disable_responder(
1137 id, getIfaceHandle(iface_name));
Roshan Piusd8e915a2016-10-28 11:23:11 -07001138}
1139
Roshan Piusabcf78f2017-10-06 16:30:38 -07001140wifi_error WifiLegacyHal::setRttLci(const std::string& iface_name,
1141 wifi_request_id id,
1142 const wifi_lci_information& info) {
1143 wifi_lci_information info_internal(info);
1144 return global_func_table_.wifi_set_lci(id, getIfaceHandle(iface_name),
1145 &info_internal);
Roshan Piusd8e915a2016-10-28 11:23:11 -07001146}
1147
Roshan Piusabcf78f2017-10-06 16:30:38 -07001148wifi_error WifiLegacyHal::setRttLcr(const std::string& iface_name,
1149 wifi_request_id id,
1150 const wifi_lcr_information& info) {
1151 wifi_lcr_information info_internal(info);
1152 return global_func_table_.wifi_set_lcr(id, getIfaceHandle(iface_name),
1153 &info_internal);
Roshan Piusd8e915a2016-10-28 11:23:11 -07001154}
1155
Roshan Pius23012092016-10-28 11:27:40 -07001156wifi_error WifiLegacyHal::nanRegisterCallbackHandlers(
Roshan Piusacededb2017-10-06 14:59:26 -07001157 const std::string& iface_name, const NanCallbackHandlers& user_callbacks) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001158 on_nan_notify_response_user_callback = user_callbacks.on_notify_response;
1159 on_nan_event_publish_terminated_user_callback =
1160 user_callbacks.on_event_publish_terminated;
1161 on_nan_event_match_user_callback = user_callbacks.on_event_match;
1162 on_nan_event_match_expired_user_callback =
1163 user_callbacks.on_event_match_expired;
1164 on_nan_event_subscribe_terminated_user_callback =
1165 user_callbacks.on_event_subscribe_terminated;
1166 on_nan_event_followup_user_callback = user_callbacks.on_event_followup;
1167 on_nan_event_disc_eng_event_user_callback =
1168 user_callbacks.on_event_disc_eng_event;
1169 on_nan_event_disabled_user_callback = user_callbacks.on_event_disabled;
1170 on_nan_event_tca_user_callback = user_callbacks.on_event_tca;
1171 on_nan_event_beacon_sdf_payload_user_callback =
1172 user_callbacks.on_event_beacon_sdf_payload;
1173 on_nan_event_data_path_request_user_callback =
1174 user_callbacks.on_event_data_path_request;
1175 on_nan_event_data_path_confirm_user_callback =
1176 user_callbacks.on_event_data_path_confirm;
1177 on_nan_event_data_path_end_user_callback =
1178 user_callbacks.on_event_data_path_end;
1179 on_nan_event_transmit_follow_up_user_callback =
1180 user_callbacks.on_event_transmit_follow_up;
1181 on_nan_event_range_request_user_callback =
1182 user_callbacks.on_event_range_request;
1183 on_nan_event_range_report_user_callback =
1184 user_callbacks.on_event_range_report;
Etan Cohen1bf15f12017-12-12 16:15:16 -08001185 on_nan_event_schedule_update_user_callback =
1186 user_callbacks.on_event_schedule_update;
Roshan Pius23012092016-10-28 11:27:40 -07001187
Roshan Piusabcf78f2017-10-06 16:30:38 -07001188 return global_func_table_.wifi_nan_register_handler(
1189 getIfaceHandle(iface_name),
1190 {onAysncNanNotifyResponse, onAysncNanEventPublishReplied,
1191 onAysncNanEventPublishTerminated, onAysncNanEventMatch,
1192 onAysncNanEventMatchExpired, onAysncNanEventSubscribeTerminated,
1193 onAysncNanEventFollowup, onAysncNanEventDiscEngEvent,
1194 onAysncNanEventDisabled, onAysncNanEventTca,
1195 onAysncNanEventBeaconSdfPayload, onAysncNanEventDataPathRequest,
1196 onAysncNanEventDataPathConfirm, onAysncNanEventDataPathEnd,
1197 onAysncNanEventTransmitFollowUp, onAysncNanEventRangeRequest,
Etan Cohen1bf15f12017-12-12 16:15:16 -08001198 onAysncNanEventRangeReport, onAsyncNanEventScheduleUpdate});
Roshan Pius23012092016-10-28 11:27:40 -07001199}
1200
Roshan Piusabcf78f2017-10-06 16:30:38 -07001201wifi_error WifiLegacyHal::nanEnableRequest(const std::string& iface_name,
1202 transaction_id id,
1203 const NanEnableRequest& msg) {
1204 NanEnableRequest msg_internal(msg);
1205 return global_func_table_.wifi_nan_enable_request(
1206 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001207}
1208
Roshan Piusabcf78f2017-10-06 16:30:38 -07001209wifi_error WifiLegacyHal::nanDisableRequest(const std::string& iface_name,
1210 transaction_id id) {
1211 return global_func_table_.wifi_nan_disable_request(
1212 id, getIfaceHandle(iface_name));
Roshan Pius23012092016-10-28 11:27:40 -07001213}
1214
Roshan Piusabcf78f2017-10-06 16:30:38 -07001215wifi_error WifiLegacyHal::nanPublishRequest(const std::string& iface_name,
1216 transaction_id id,
1217 const NanPublishRequest& msg) {
1218 NanPublishRequest msg_internal(msg);
1219 return global_func_table_.wifi_nan_publish_request(
1220 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001221}
1222
1223wifi_error WifiLegacyHal::nanPublishCancelRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001224 const std::string& iface_name, transaction_id id,
1225 const NanPublishCancelRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001226 NanPublishCancelRequest msg_internal(msg);
1227 return global_func_table_.wifi_nan_publish_cancel_request(
1228 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001229}
1230
Roshan Piusabcf78f2017-10-06 16:30:38 -07001231wifi_error WifiLegacyHal::nanSubscribeRequest(const std::string& iface_name,
1232 transaction_id id,
1233 const NanSubscribeRequest& msg) {
1234 NanSubscribeRequest msg_internal(msg);
1235 return global_func_table_.wifi_nan_subscribe_request(
1236 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001237}
1238
1239wifi_error WifiLegacyHal::nanSubscribeCancelRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001240 const std::string& iface_name, transaction_id id,
1241 const NanSubscribeCancelRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001242 NanSubscribeCancelRequest msg_internal(msg);
1243 return global_func_table_.wifi_nan_subscribe_cancel_request(
1244 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001245}
1246
1247wifi_error WifiLegacyHal::nanTransmitFollowupRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001248 const std::string& iface_name, transaction_id id,
1249 const NanTransmitFollowupRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001250 NanTransmitFollowupRequest msg_internal(msg);
1251 return global_func_table_.wifi_nan_transmit_followup_request(
1252 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001253}
1254
Roshan Piusabcf78f2017-10-06 16:30:38 -07001255wifi_error WifiLegacyHal::nanStatsRequest(const std::string& iface_name,
1256 transaction_id id,
1257 const NanStatsRequest& msg) {
1258 NanStatsRequest msg_internal(msg);
1259 return global_func_table_.wifi_nan_stats_request(
1260 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001261}
1262
Roshan Piusabcf78f2017-10-06 16:30:38 -07001263wifi_error WifiLegacyHal::nanConfigRequest(const std::string& iface_name,
1264 transaction_id id,
1265 const NanConfigRequest& msg) {
1266 NanConfigRequest msg_internal(msg);
1267 return global_func_table_.wifi_nan_config_request(
1268 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001269}
1270
Roshan Piusabcf78f2017-10-06 16:30:38 -07001271wifi_error WifiLegacyHal::nanTcaRequest(const std::string& iface_name,
1272 transaction_id id,
1273 const NanTCARequest& msg) {
1274 NanTCARequest msg_internal(msg);
1275 return global_func_table_.wifi_nan_tca_request(
1276 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001277}
1278
1279wifi_error WifiLegacyHal::nanBeaconSdfPayloadRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001280 const std::string& iface_name, transaction_id id,
1281 const NanBeaconSdfPayloadRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001282 NanBeaconSdfPayloadRequest msg_internal(msg);
1283 return global_func_table_.wifi_nan_beacon_sdf_payload_request(
1284 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001285}
1286
1287std::pair<wifi_error, NanVersion> WifiLegacyHal::nanGetVersion() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001288 NanVersion version;
1289 wifi_error status =
1290 global_func_table_.wifi_nan_get_version(global_handle_, &version);
1291 return {status, version};
Roshan Pius23012092016-10-28 11:27:40 -07001292}
1293
Roshan Piusabcf78f2017-10-06 16:30:38 -07001294wifi_error WifiLegacyHal::nanGetCapabilities(const std::string& iface_name,
1295 transaction_id id) {
1296 return global_func_table_.wifi_nan_get_capabilities(
1297 id, getIfaceHandle(iface_name));
Roshan Pius23012092016-10-28 11:27:40 -07001298}
1299
1300wifi_error WifiLegacyHal::nanDataInterfaceCreate(
Roshan Piusacededb2017-10-06 14:59:26 -07001301 const std::string& iface_name, transaction_id id,
1302 const std::string& data_iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001303 return global_func_table_.wifi_nan_data_interface_create(
1304 id, getIfaceHandle(iface_name), makeCharVec(data_iface_name).data());
Roshan Pius23012092016-10-28 11:27:40 -07001305}
1306
1307wifi_error WifiLegacyHal::nanDataInterfaceDelete(
Roshan Piusacededb2017-10-06 14:59:26 -07001308 const std::string& iface_name, transaction_id id,
1309 const std::string& data_iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001310 return global_func_table_.wifi_nan_data_interface_delete(
1311 id, getIfaceHandle(iface_name), makeCharVec(data_iface_name).data());
Roshan Pius23012092016-10-28 11:27:40 -07001312}
1313
1314wifi_error WifiLegacyHal::nanDataRequestInitiator(
Roshan Piusacededb2017-10-06 14:59:26 -07001315 const std::string& iface_name, transaction_id id,
1316 const NanDataPathInitiatorRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001317 NanDataPathInitiatorRequest msg_internal(msg);
1318 return global_func_table_.wifi_nan_data_request_initiator(
1319 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001320}
1321
1322wifi_error WifiLegacyHal::nanDataIndicationResponse(
Roshan Piusacededb2017-10-06 14:59:26 -07001323 const std::string& iface_name, transaction_id id,
1324 const NanDataPathIndicationResponse& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001325 NanDataPathIndicationResponse msg_internal(msg);
1326 return global_func_table_.wifi_nan_data_indication_response(
1327 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001328}
1329
Etan Cohenc9836f92017-06-30 13:55:21 -07001330typedef struct {
1331 u8 num_ndp_instances;
1332 NanDataPathId ndp_instance_id;
1333} NanDataPathEndSingleNdpIdRequest;
1334
Roshan Piusabcf78f2017-10-06 16:30:38 -07001335wifi_error WifiLegacyHal::nanDataEnd(const std::string& iface_name,
1336 transaction_id id,
1337 uint32_t ndpInstanceId) {
1338 NanDataPathEndSingleNdpIdRequest msg;
1339 msg.num_ndp_instances = 1;
1340 msg.ndp_instance_id = ndpInstanceId;
1341 wifi_error status = global_func_table_.wifi_nan_data_end(
1342 id, getIfaceHandle(iface_name), (NanDataPathEndRequest*)&msg);
1343 return status;
Roshan Pius23012092016-10-28 11:27:40 -07001344}
1345
Roshan Piusabcf78f2017-10-06 16:30:38 -07001346wifi_error WifiLegacyHal::setCountryCode(const std::string& iface_name,
1347 std::array<int8_t, 2> code) {
1348 std::string code_str(code.data(), code.data() + code.size());
1349 return global_func_table_.wifi_set_country_code(getIfaceHandle(iface_name),
1350 code_str.c_str());
Roshan Pius32fc12e2017-01-25 17:44:42 -08001351}
1352
Roshan Piusacededb2017-10-06 14:59:26 -07001353wifi_error WifiLegacyHal::retrieveIfaceHandles() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001354 wifi_interface_handle* iface_handles = nullptr;
1355 int num_iface_handles = 0;
1356 wifi_error status = global_func_table_.wifi_get_ifaces(
1357 global_handle_, &num_iface_handles, &iface_handles);
Roshan Piusaabe5752016-09-29 09:03:59 -07001358 if (status != WIFI_SUCCESS) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001359 LOG(ERROR) << "Failed to enumerate interface handles";
1360 return status;
Roshan Piusaabe5752016-09-29 09:03:59 -07001361 }
Sunil Raviddab4bb2020-02-03 22:45:19 -08001362 iface_name_to_handle_.clear();
Roshan Piusabcf78f2017-10-06 16:30:38 -07001363 for (int i = 0; i < num_iface_handles; ++i) {
1364 std::array<char, IFNAMSIZ> iface_name_arr = {};
1365 status = global_func_table_.wifi_get_iface_name(
1366 iface_handles[i], iface_name_arr.data(), iface_name_arr.size());
1367 if (status != WIFI_SUCCESS) {
1368 LOG(WARNING) << "Failed to get interface handle name";
1369 continue;
1370 }
1371 // Assuming the interface name is null terminated since the legacy HAL
1372 // API does not return a size.
1373 std::string iface_name(iface_name_arr.data());
1374 LOG(INFO) << "Adding interface handle for " << iface_name;
1375 iface_name_to_handle_[iface_name] = iface_handles[i];
1376 }
1377 return WIFI_SUCCESS;
Roshan Piusacededb2017-10-06 14:59:26 -07001378}
1379
1380wifi_interface_handle WifiLegacyHal::getIfaceHandle(
1381 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001382 const auto iface_handle_iter = iface_name_to_handle_.find(iface_name);
1383 if (iface_handle_iter == iface_name_to_handle_.end()) {
1384 LOG(ERROR) << "Unknown iface name: " << iface_name;
1385 return nullptr;
1386 }
1387 return iface_handle_iter->second;
Roshan Piusaabe5752016-09-29 09:03:59 -07001388}
1389
1390void WifiLegacyHal::runEventLoop() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001391 LOG(DEBUG) << "Starting legacy HAL event loop";
1392 global_func_table_.wifi_event_loop(global_handle_);
1393 const auto lock = hidl_sync_util::acquireGlobalLock();
1394 if (!awaiting_event_loop_termination_) {
1395 LOG(FATAL)
1396 << "Legacy HAL event loop terminated, but HAL was not stopping";
1397 }
1398 LOG(DEBUG) << "Legacy HAL event loop terminated";
1399 awaiting_event_loop_termination_ = false;
1400 stop_wait_cv_.notify_one();
Roshan Piusaabe5752016-09-29 09:03:59 -07001401}
1402
Roshan Pius76ff3022016-10-28 10:33:34 -07001403std::pair<wifi_error, std::vector<wifi_cached_scan_results>>
Roshan Piusacededb2017-10-06 14:59:26 -07001404WifiLegacyHal::getGscanCachedResults(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001405 std::vector<wifi_cached_scan_results> cached_scan_results;
1406 cached_scan_results.resize(kMaxCachedGscanResults);
1407 int32_t num_results = 0;
1408 wifi_error status = global_func_table_.wifi_get_cached_gscan_results(
1409 getIfaceHandle(iface_name), true /* always flush */,
1410 cached_scan_results.size(), cached_scan_results.data(), &num_results);
1411 CHECK(num_results >= 0 &&
1412 static_cast<uint32_t>(num_results) <= kMaxCachedGscanResults);
1413 cached_scan_results.resize(num_results);
1414 // Check for invalid IE lengths in these cached scan results and correct it.
1415 for (auto& cached_scan_result : cached_scan_results) {
1416 int num_scan_results = cached_scan_result.num_results;
1417 for (int i = 0; i < num_scan_results; i++) {
1418 auto& scan_result = cached_scan_result.results[i];
1419 if (scan_result.ie_length > 0) {
1420 LOG(DEBUG) << "Cached scan result has non-zero IE length "
1421 << scan_result.ie_length;
1422 scan_result.ie_length = 0;
1423 }
1424 }
Roshan Pius76ff3022016-10-28 10:33:34 -07001425 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001426 return {status, std::move(cached_scan_results)};
Roshan Pius76ff3022016-10-28 10:33:34 -07001427}
1428
Sunil Raviddab4bb2020-02-03 22:45:19 -08001429wifi_error WifiLegacyHal::createVirtualInterface(const std::string& ifname,
1430 wifi_interface_type iftype) {
1431 // Create the interface if it doesn't exist. If interface already exist,
1432 // Vendor Hal should return WIFI_SUCCESS.
1433 wifi_error status = global_func_table_.wifi_virtual_interface_create(
1434 global_handle_, ifname.c_str(), iftype);
1435 return handleVirtualInterfaceCreateOrDeleteStatus(ifname, status);
1436}
1437
1438wifi_error WifiLegacyHal::deleteVirtualInterface(const std::string& ifname) {
1439 // Delete the interface if it was created dynamically.
1440 wifi_error status = global_func_table_.wifi_virtual_interface_delete(
1441 global_handle_, ifname.c_str());
1442 return handleVirtualInterfaceCreateOrDeleteStatus(ifname, status);
1443}
1444
1445wifi_error WifiLegacyHal::handleVirtualInterfaceCreateOrDeleteStatus(
1446 const std::string& ifname, wifi_error status) {
1447 if (status == WIFI_SUCCESS) {
1448 // refresh list of handlers now.
1449 status = retrieveIfaceHandles();
1450 } else if (status == WIFI_ERROR_NOT_SUPPORTED) {
1451 // Vendor hal does not implement this API. Such vendor implementations
1452 // are expected to create / delete interface by other means.
1453
1454 // check if interface exists.
1455 if (if_nametoindex(ifname.c_str())) {
1456 status = retrieveIfaceHandles();
1457 }
1458 }
1459 return status;
1460}
1461
Roshan Pius511cc492016-10-28 09:54:26 -07001462void WifiLegacyHal::invalidate() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001463 global_handle_ = nullptr;
1464 iface_name_to_handle_.clear();
1465 on_driver_memory_dump_internal_callback = nullptr;
1466 on_firmware_memory_dump_internal_callback = nullptr;
1467 on_gscan_event_internal_callback = nullptr;
1468 on_gscan_full_result_internal_callback = nullptr;
1469 on_link_layer_stats_result_internal_callback = nullptr;
1470 on_rssi_threshold_breached_internal_callback = nullptr;
1471 on_ring_buffer_data_internal_callback = nullptr;
1472 on_error_alert_internal_callback = nullptr;
Roshan Pius01f08772018-01-22 17:56:06 -08001473 on_radio_mode_change_internal_callback = nullptr;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001474 on_rtt_results_internal_callback = nullptr;
1475 on_nan_notify_response_user_callback = nullptr;
1476 on_nan_event_publish_terminated_user_callback = nullptr;
1477 on_nan_event_match_user_callback = nullptr;
1478 on_nan_event_match_expired_user_callback = nullptr;
1479 on_nan_event_subscribe_terminated_user_callback = nullptr;
1480 on_nan_event_followup_user_callback = nullptr;
1481 on_nan_event_disc_eng_event_user_callback = nullptr;
1482 on_nan_event_disabled_user_callback = nullptr;
1483 on_nan_event_tca_user_callback = nullptr;
1484 on_nan_event_beacon_sdf_payload_user_callback = nullptr;
1485 on_nan_event_data_path_request_user_callback = nullptr;
1486 on_nan_event_data_path_confirm_user_callback = nullptr;
1487 on_nan_event_data_path_end_user_callback = nullptr;
1488 on_nan_event_transmit_follow_up_user_callback = nullptr;
1489 on_nan_event_range_request_user_callback = nullptr;
1490 on_nan_event_range_report_user_callback = nullptr;
Etan Cohen1bf15f12017-12-12 16:15:16 -08001491 on_nan_event_schedule_update_user_callback = nullptr;
Roshan Pius511cc492016-10-28 09:54:26 -07001492}
Roshan Pius955542e2016-10-28 09:42:44 -07001493
1494} // namespace legacy_hal
Roshan Piusaabe5752016-09-29 09:03:59 -07001495} // namespace implementation
Ahmed ElArabawyf501a982019-07-23 15:02:22 -07001496} // namespace V1_4
Roshan Piusaabe5752016-09-29 09:03:59 -07001497} // namespace wifi
1498} // namespace hardware
1499} // namespace android