blob: 848fbd6114c4df81a9c5e885356c8329641d12d4 [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;
Kumar Anand2a630a32021-01-21 14:09:14 -080039static constexpr uint32_t kMaxWifiUsableChannels = 256;
Jimmy Chen2dddd792019-12-23 17:50:39 +020040// need a long timeout (1000ms) for chips that unload their driver.
41static constexpr uint32_t kMaxStopCompleteWaitMs = 1000;
Ahmed ElArabawy7153e812018-06-05 11:09:39 -070042static constexpr char kDriverPropName[] = "wlan.driver.status";
Roshan Pius511cc492016-10-28 09:54:26 -070043
Roshan Pius32fc12e2017-01-25 17:44:42 -080044// Helper function to create a non-const char* for legacy Hal API's.
45std::vector<char> makeCharVec(const std::string& str) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070046 std::vector<char> vec(str.size() + 1);
47 vec.assign(str.begin(), str.end());
48 vec.push_back('\0');
49 return vec;
Roshan Pius32fc12e2017-01-25 17:44:42 -080050}
51} // namespace
52
53namespace android {
54namespace hardware {
55namespace wifi {
Jimmy Chend460df32019-11-29 17:31:22 +020056namespace V1_5 {
Roshan Pius32fc12e2017-01-25 17:44:42 -080057namespace implementation {
58namespace legacy_hal {
Jimmy Chen2dddd792019-12-23 17:50:39 +020059
Roshan Piusaabe5752016-09-29 09:03:59 -070060// Legacy HAL functions accept "C" style function pointers, so use global
61// functions to pass to the legacy HAL function and store the corresponding
62// std::function methods to be invoked.
Roshan Pius155344b2017-08-11 15:47:42 -070063//
64// Callback to be invoked once |stop| is complete
Roshan Piusaabe5752016-09-29 09:03:59 -070065std::function<void(wifi_handle handle)> on_stop_complete_internal_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -080066void onAsyncStopComplete(wifi_handle handle) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070067 const auto lock = hidl_sync_util::acquireGlobalLock();
68 if (on_stop_complete_internal_callback) {
69 on_stop_complete_internal_callback(handle);
70 // Invalidate this callback since we don't want this firing again.
71 on_stop_complete_internal_callback = nullptr;
72 }
Roshan Piusaabe5752016-09-29 09:03:59 -070073}
Roshan Piuscdb77f32016-10-03 14:09:57 -070074
75// Callback to be invoked for driver dump.
76std::function<void(char*, int)> on_driver_memory_dump_internal_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -080077void onSyncDriverMemoryDump(char* buffer, int buffer_size) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070078 if (on_driver_memory_dump_internal_callback) {
79 on_driver_memory_dump_internal_callback(buffer, buffer_size);
80 }
Roshan Piuscdb77f32016-10-03 14:09:57 -070081}
82
83// Callback to be invoked for firmware dump.
84std::function<void(char*, int)> on_firmware_memory_dump_internal_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -080085void onSyncFirmwareMemoryDump(char* buffer, int buffer_size) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070086 if (on_firmware_memory_dump_internal_callback) {
87 on_firmware_memory_dump_internal_callback(buffer, buffer_size);
88 }
Roshan Piuscdb77f32016-10-03 14:09:57 -070089}
Roshan Pius76ff3022016-10-28 10:33:34 -070090
91// Callback to be invoked for Gscan events.
92std::function<void(wifi_request_id, wifi_scan_event)>
93 on_gscan_event_internal_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -080094void onAsyncGscanEvent(wifi_request_id id, wifi_scan_event event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070095 const auto lock = hidl_sync_util::acquireGlobalLock();
96 if (on_gscan_event_internal_callback) {
97 on_gscan_event_internal_callback(id, event);
98 }
Roshan Pius76ff3022016-10-28 10:33:34 -070099}
100
101// Callback to be invoked for Gscan full results.
102std::function<void(wifi_request_id, wifi_scan_result*, uint32_t)>
103 on_gscan_full_result_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700104void onAsyncGscanFullResult(wifi_request_id id, wifi_scan_result* result,
Roshan Pius091e1c12017-01-30 16:40:50 -0800105 uint32_t buckets_scanned) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700106 const auto lock = hidl_sync_util::acquireGlobalLock();
107 if (on_gscan_full_result_internal_callback) {
108 on_gscan_full_result_internal_callback(id, result, buckets_scanned);
109 }
Roshan Pius76ff3022016-10-28 10:33:34 -0700110}
111
Roshan Pius7cece412016-10-28 10:38:21 -0700112// Callback to be invoked for link layer stats results.
113std::function<void((wifi_request_id, wifi_iface_stat*, int, wifi_radio_stat*))>
114 on_link_layer_stats_result_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700115void onSyncLinkLayerStatsResult(wifi_request_id id, wifi_iface_stat* iface_stat,
116 int num_radios, wifi_radio_stat* radio_stat) {
117 if (on_link_layer_stats_result_internal_callback) {
118 on_link_layer_stats_result_internal_callback(id, iface_stat, num_radios,
119 radio_stat);
120 }
Roshan Pius7cece412016-10-28 10:38:21 -0700121}
122
Roshan Piusd4767542016-12-06 10:04:05 -0800123// Callback to be invoked for rssi threshold breach.
124std::function<void((wifi_request_id, uint8_t*, int8_t))>
125 on_rssi_threshold_breached_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700126void onAsyncRssiThresholdBreached(wifi_request_id id, uint8_t* bssid,
Roshan Pius091e1c12017-01-30 16:40:50 -0800127 int8_t rssi) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700128 const auto lock = hidl_sync_util::acquireGlobalLock();
129 if (on_rssi_threshold_breached_internal_callback) {
130 on_rssi_threshold_breached_internal_callback(id, bssid, rssi);
131 }
Roshan Piusd4767542016-12-06 10:04:05 -0800132}
133
Roshan Pius8714a3e2016-10-28 10:43:51 -0700134// Callback to be invoked for ring buffer data indication.
135std::function<void(char*, char*, int, wifi_ring_buffer_status*)>
136 on_ring_buffer_data_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700137void onAsyncRingBufferData(char* ring_name, char* buffer, int buffer_size,
Roshan Pius091e1c12017-01-30 16:40:50 -0800138 wifi_ring_buffer_status* status) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700139 const auto lock = hidl_sync_util::acquireGlobalLock();
140 if (on_ring_buffer_data_internal_callback) {
141 on_ring_buffer_data_internal_callback(ring_name, buffer, buffer_size,
142 status);
143 }
Roshan Pius8714a3e2016-10-28 10:43:51 -0700144}
145
Roshan Pius203cb032016-12-14 17:41:20 -0800146// Callback to be invoked for error alert indication.
147std::function<void(wifi_request_id, char*, int, int)>
148 on_error_alert_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700149void onAsyncErrorAlert(wifi_request_id id, char* buffer, int buffer_size,
Roshan Pius091e1c12017-01-30 16:40:50 -0800150 int err_code) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700151 const auto lock = hidl_sync_util::acquireGlobalLock();
152 if (on_error_alert_internal_callback) {
153 on_error_alert_internal_callback(id, buffer, buffer_size, err_code);
154 }
Roshan Pius203cb032016-12-14 17:41:20 -0800155}
156
Roshan Pius01f08772018-01-22 17:56:06 -0800157// Callback to be invoked for radio mode change indication.
158std::function<void(wifi_request_id, uint32_t, wifi_mac_info*)>
159 on_radio_mode_change_internal_callback;
160void onAsyncRadioModeChange(wifi_request_id id, uint32_t num_macs,
161 wifi_mac_info* mac_infos) {
162 const auto lock = hidl_sync_util::acquireGlobalLock();
163 if (on_radio_mode_change_internal_callback) {
164 on_radio_mode_change_internal_callback(id, num_macs, mac_infos);
165 }
166}
167
Ahmed ElArabawy2134bf72020-06-18 15:07:12 -0700168// Callback to be invoked to report subsystem restart
169std::function<void(const char*)> on_subsystem_restart_internal_callback;
170void onAsyncSubsystemRestart(const char* error) {
171 const auto lock = hidl_sync_util::acquireGlobalLock();
172 if (on_subsystem_restart_internal_callback) {
173 on_subsystem_restart_internal_callback(error);
174 }
175}
176
Roshan Piusd8e915a2016-10-28 11:23:11 -0700177// Callback to be invoked for rtt results results.
Roshan Piusabcf78f2017-10-06 16:30:38 -0700178std::function<void(wifi_request_id, unsigned num_results,
179 wifi_rtt_result* rtt_results[])>
Roshan Piusd8e915a2016-10-28 11:23:11 -0700180 on_rtt_results_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700181void onAsyncRttResults(wifi_request_id id, unsigned num_results,
Roshan Pius091e1c12017-01-30 16:40:50 -0800182 wifi_rtt_result* rtt_results[]) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700183 const auto lock = hidl_sync_util::acquireGlobalLock();
184 if (on_rtt_results_internal_callback) {
185 on_rtt_results_internal_callback(id, num_results, rtt_results);
186 on_rtt_results_internal_callback = nullptr;
187 }
Roshan Piusd8e915a2016-10-28 11:23:11 -0700188}
189
Roshan Pius23012092016-10-28 11:27:40 -0700190// Callbacks for the various NAN operations.
191// NOTE: These have very little conversions to perform before invoking the user
192// callbacks.
193// So, handle all of them here directly to avoid adding an unnecessary layer.
194std::function<void(transaction_id, const NanResponseMsg&)>
195 on_nan_notify_response_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800196void onAysncNanNotifyResponse(transaction_id id, NanResponseMsg* msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700197 const auto lock = hidl_sync_util::acquireGlobalLock();
198 if (on_nan_notify_response_user_callback && msg) {
199 on_nan_notify_response_user_callback(id, *msg);
200 }
Roshan Pius23012092016-10-28 11:27:40 -0700201}
202
Etan Cohen20925b02017-04-04 13:00:14 -0700203std::function<void(const NanPublishRepliedInd&)>
204 on_nan_event_publish_replied_user_callback;
205void onAysncNanEventPublishReplied(NanPublishRepliedInd* /* event */) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700206 LOG(ERROR) << "onAysncNanEventPublishReplied triggered";
Etan Cohen20925b02017-04-04 13:00:14 -0700207}
208
Roshan Pius23012092016-10-28 11:27:40 -0700209std::function<void(const NanPublishTerminatedInd&)>
210 on_nan_event_publish_terminated_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800211void onAysncNanEventPublishTerminated(NanPublishTerminatedInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700212 const auto lock = hidl_sync_util::acquireGlobalLock();
213 if (on_nan_event_publish_terminated_user_callback && event) {
214 on_nan_event_publish_terminated_user_callback(*event);
215 }
Roshan Pius23012092016-10-28 11:27:40 -0700216}
217
218std::function<void(const NanMatchInd&)> on_nan_event_match_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800219void onAysncNanEventMatch(NanMatchInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700220 const auto lock = hidl_sync_util::acquireGlobalLock();
221 if (on_nan_event_match_user_callback && event) {
222 on_nan_event_match_user_callback(*event);
223 }
Roshan Pius23012092016-10-28 11:27:40 -0700224}
225
226std::function<void(const NanMatchExpiredInd&)>
227 on_nan_event_match_expired_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800228void onAysncNanEventMatchExpired(NanMatchExpiredInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700229 const auto lock = hidl_sync_util::acquireGlobalLock();
230 if (on_nan_event_match_expired_user_callback && event) {
231 on_nan_event_match_expired_user_callback(*event);
232 }
Roshan Pius23012092016-10-28 11:27:40 -0700233}
234
235std::function<void(const NanSubscribeTerminatedInd&)>
236 on_nan_event_subscribe_terminated_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800237void onAysncNanEventSubscribeTerminated(NanSubscribeTerminatedInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700238 const auto lock = hidl_sync_util::acquireGlobalLock();
239 if (on_nan_event_subscribe_terminated_user_callback && event) {
240 on_nan_event_subscribe_terminated_user_callback(*event);
241 }
Roshan Pius23012092016-10-28 11:27:40 -0700242}
243
244std::function<void(const NanFollowupInd&)> on_nan_event_followup_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800245void onAysncNanEventFollowup(NanFollowupInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700246 const auto lock = hidl_sync_util::acquireGlobalLock();
247 if (on_nan_event_followup_user_callback && event) {
248 on_nan_event_followup_user_callback(*event);
249 }
Roshan Pius23012092016-10-28 11:27:40 -0700250}
251
252std::function<void(const NanDiscEngEventInd&)>
253 on_nan_event_disc_eng_event_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800254void onAysncNanEventDiscEngEvent(NanDiscEngEventInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700255 const auto lock = hidl_sync_util::acquireGlobalLock();
256 if (on_nan_event_disc_eng_event_user_callback && event) {
257 on_nan_event_disc_eng_event_user_callback(*event);
258 }
Roshan Pius23012092016-10-28 11:27:40 -0700259}
260
261std::function<void(const NanDisabledInd&)> on_nan_event_disabled_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800262void onAysncNanEventDisabled(NanDisabledInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700263 const auto lock = hidl_sync_util::acquireGlobalLock();
264 if (on_nan_event_disabled_user_callback && event) {
265 on_nan_event_disabled_user_callback(*event);
266 }
Roshan Pius23012092016-10-28 11:27:40 -0700267}
268
269std::function<void(const NanTCAInd&)> on_nan_event_tca_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800270void onAysncNanEventTca(NanTCAInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700271 const auto lock = hidl_sync_util::acquireGlobalLock();
272 if (on_nan_event_tca_user_callback && event) {
273 on_nan_event_tca_user_callback(*event);
274 }
Roshan Pius23012092016-10-28 11:27:40 -0700275}
276
277std::function<void(const NanBeaconSdfPayloadInd&)>
278 on_nan_event_beacon_sdf_payload_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800279void onAysncNanEventBeaconSdfPayload(NanBeaconSdfPayloadInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700280 const auto lock = hidl_sync_util::acquireGlobalLock();
281 if (on_nan_event_beacon_sdf_payload_user_callback && event) {
282 on_nan_event_beacon_sdf_payload_user_callback(*event);
283 }
Roshan Pius23012092016-10-28 11:27:40 -0700284}
285
286std::function<void(const NanDataPathRequestInd&)>
287 on_nan_event_data_path_request_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800288void onAysncNanEventDataPathRequest(NanDataPathRequestInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700289 const auto lock = hidl_sync_util::acquireGlobalLock();
290 if (on_nan_event_data_path_request_user_callback && event) {
291 on_nan_event_data_path_request_user_callback(*event);
292 }
Roshan Pius23012092016-10-28 11:27:40 -0700293}
294std::function<void(const NanDataPathConfirmInd&)>
295 on_nan_event_data_path_confirm_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800296void onAysncNanEventDataPathConfirm(NanDataPathConfirmInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700297 const auto lock = hidl_sync_util::acquireGlobalLock();
298 if (on_nan_event_data_path_confirm_user_callback && event) {
299 on_nan_event_data_path_confirm_user_callback(*event);
300 }
Roshan Pius23012092016-10-28 11:27:40 -0700301}
302
303std::function<void(const NanDataPathEndInd&)>
304 on_nan_event_data_path_end_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800305void onAysncNanEventDataPathEnd(NanDataPathEndInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700306 const auto lock = hidl_sync_util::acquireGlobalLock();
307 if (on_nan_event_data_path_end_user_callback && event) {
308 on_nan_event_data_path_end_user_callback(*event);
309 }
Roshan Pius23012092016-10-28 11:27:40 -0700310}
311
312std::function<void(const NanTransmitFollowupInd&)>
313 on_nan_event_transmit_follow_up_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800314void onAysncNanEventTransmitFollowUp(NanTransmitFollowupInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700315 const auto lock = hidl_sync_util::acquireGlobalLock();
316 if (on_nan_event_transmit_follow_up_user_callback && event) {
317 on_nan_event_transmit_follow_up_user_callback(*event);
318 }
Roshan Pius23012092016-10-28 11:27:40 -0700319}
Etan Cohenc190f932017-02-17 13:06:55 -0800320
321std::function<void(const NanRangeRequestInd&)>
322 on_nan_event_range_request_user_callback;
323void onAysncNanEventRangeRequest(NanRangeRequestInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700324 const auto lock = hidl_sync_util::acquireGlobalLock();
325 if (on_nan_event_range_request_user_callback && event) {
326 on_nan_event_range_request_user_callback(*event);
327 }
Etan Cohenc190f932017-02-17 13:06:55 -0800328}
329
330std::function<void(const NanRangeReportInd&)>
331 on_nan_event_range_report_user_callback;
332void onAysncNanEventRangeReport(NanRangeReportInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700333 const auto lock = hidl_sync_util::acquireGlobalLock();
334 if (on_nan_event_range_report_user_callback && event) {
335 on_nan_event_range_report_user_callback(*event);
336 }
Etan Cohenc190f932017-02-17 13:06:55 -0800337}
Etan Cohen1bf15f12017-12-12 16:15:16 -0800338
339std::function<void(const NanDataPathScheduleUpdateInd&)>
340 on_nan_event_schedule_update_user_callback;
341void onAsyncNanEventScheduleUpdate(NanDataPathScheduleUpdateInd* event) {
342 const auto lock = hidl_sync_util::acquireGlobalLock();
343 if (on_nan_event_schedule_update_user_callback && event) {
344 on_nan_event_schedule_update_user_callback(*event);
345 }
346}
Kai Shi2ca7a112020-12-15 19:51:28 -0800347
348// Callbacks for the various TWT operations.
349std::function<void(const TwtSetupResponse&)>
350 on_twt_event_setup_response_callback;
351void onAsyncTwtEventSetupResponse(TwtSetupResponse* event) {
352 const auto lock = hidl_sync_util::acquireGlobalLock();
353 if (on_twt_event_setup_response_callback && event) {
354 on_twt_event_setup_response_callback(*event);
355 }
356}
357
358std::function<void(const TwtTeardownCompletion&)>
359 on_twt_event_teardown_completion_callback;
360void onAsyncTwtEventTeardownCompletion(TwtTeardownCompletion* event) {
361 const auto lock = hidl_sync_util::acquireGlobalLock();
362 if (on_twt_event_teardown_completion_callback && event) {
363 on_twt_event_teardown_completion_callback(*event);
364 }
365}
366
367std::function<void(const TwtInfoFrameReceived&)>
368 on_twt_event_info_frame_received_callback;
369void onAsyncTwtEventInfoFrameReceived(TwtInfoFrameReceived* event) {
370 const auto lock = hidl_sync_util::acquireGlobalLock();
371 if (on_twt_event_info_frame_received_callback && event) {
372 on_twt_event_info_frame_received_callback(*event);
373 }
374}
375
376std::function<void(const TwtDeviceNotify&)> on_twt_event_device_notify_callback;
377void onAsyncTwtEventDeviceNotify(TwtDeviceNotify* event) {
378 const auto lock = hidl_sync_util::acquireGlobalLock();
379 if (on_twt_event_device_notify_callback && event) {
380 on_twt_event_device_notify_callback(*event);
381 }
382}
383
Roshan Pius955542e2016-10-28 09:42:44 -0700384// End of the free-standing "C" style callbacks.
Roshan Piusaabe5752016-09-29 09:03:59 -0700385
Roshan Piusc885df02019-05-21 14:49:05 -0700386WifiLegacyHal::WifiLegacyHal(
Jimmy Chen2dddd792019-12-23 17:50:39 +0200387 const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
388 const wifi_hal_fn& fn, bool is_primary)
389 : global_func_table_(fn),
390 global_handle_(nullptr),
Roshan Pius11f93032016-12-09 10:26:17 -0800391 awaiting_event_loop_termination_(false),
Roshan Piusc885df02019-05-21 14:49:05 -0700392 is_started_(false),
Jimmy Chen2dddd792019-12-23 17:50:39 +0200393 iface_tool_(iface_tool),
394 is_primary_(is_primary) {}
Roshan Piusaabe5752016-09-29 09:03:59 -0700395
Roshan Pius97334112016-11-18 14:07:54 -0800396wifi_error WifiLegacyHal::initialize() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700397 LOG(DEBUG) << "Initialize legacy HAL";
Jimmy Chen2dddd792019-12-23 17:50:39 +0200398 // this now does nothing, since HAL function table is provided
399 // to the constructor
400 return WIFI_SUCCESS;
Roshan Pius97334112016-11-18 14:07:54 -0800401}
402
403wifi_error WifiLegacyHal::start() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700404 // Ensure that we're starting in a good state.
405 CHECK(global_func_table_.wifi_initialize && !global_handle_ &&
406 iface_name_to_handle_.empty() && !awaiting_event_loop_termination_);
407 if (is_started_) {
408 LOG(DEBUG) << "Legacy HAL already started";
409 return WIFI_SUCCESS;
410 }
Ahmed ElArabawyc1018152018-03-02 14:35:04 -0800411 LOG(DEBUG) << "Waiting for the driver ready";
412 wifi_error status = global_func_table_.wifi_wait_for_driver_ready();
Veerendranath Jakkamb3d43482020-06-11 20:12:48 +0530413 if (status == WIFI_ERROR_TIMED_OUT || status == WIFI_ERROR_UNKNOWN) {
414 LOG(ERROR) << "Failed or timed out awaiting driver ready";
Ahmed ElArabawyc1018152018-03-02 14:35:04 -0800415 return status;
416 }
Jimmy Chen2dddd792019-12-23 17:50:39 +0200417
418 if (is_primary_) {
419 property_set(kDriverPropName, "ok");
420
421 if (!iface_tool_.lock()->SetWifiUpState(true)) {
422 LOG(ERROR) << "Failed to set WiFi interface up";
423 return WIFI_ERROR_UNKNOWN;
424 }
425 }
Ahmed ElArabawy7153e812018-06-05 11:09:39 -0700426
Roshan Piusabcf78f2017-10-06 16:30:38 -0700427 LOG(DEBUG) << "Starting legacy HAL";
Ahmed ElArabawyc1018152018-03-02 14:35:04 -0800428 status = global_func_table_.wifi_initialize(&global_handle_);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700429 if (status != WIFI_SUCCESS || !global_handle_) {
430 LOG(ERROR) << "Failed to retrieve global handle";
431 return status;
432 }
433 std::thread(&WifiLegacyHal::runEventLoop, this).detach();
434 status = retrieveIfaceHandles();
435 if (status != WIFI_SUCCESS || iface_name_to_handle_.empty()) {
436 LOG(ERROR) << "Failed to retrieve wlan interface handle";
437 return status;
438 }
439 LOG(DEBUG) << "Legacy HAL start complete";
440 is_started_ = true;
Roshan Pius11f93032016-12-09 10:26:17 -0800441 return WIFI_SUCCESS;
Roshan Piusaabe5752016-09-29 09:03:59 -0700442}
443
444wifi_error WifiLegacyHal::stop(
Roshan Pius155344b2017-08-11 15:47:42 -0700445 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock,
Roshan Piusaabe5752016-09-29 09:03:59 -0700446 const std::function<void()>& on_stop_complete_user_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700447 if (!is_started_) {
448 LOG(DEBUG) << "Legacy HAL already stopped";
449 on_stop_complete_user_callback();
450 return WIFI_SUCCESS;
451 }
452 LOG(DEBUG) << "Stopping legacy HAL";
453 on_stop_complete_internal_callback = [on_stop_complete_user_callback,
454 this](wifi_handle handle) {
455 CHECK_EQ(global_handle_, handle) << "Handle mismatch";
456 LOG(INFO) << "Legacy HAL stop complete callback received";
457 // Invalidate all the internal pointers now that the HAL is
458 // stopped.
459 invalidate();
Jimmy Chen2dddd792019-12-23 17:50:39 +0200460 if (is_primary_) iface_tool_.lock()->SetWifiUpState(false);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700461 on_stop_complete_user_callback();
462 is_started_ = false;
463 };
464 awaiting_event_loop_termination_ = true;
465 global_func_table_.wifi_cleanup(global_handle_, onAsyncStopComplete);
466 const auto status = stop_wait_cv_.wait_for(
467 *lock, std::chrono::milliseconds(kMaxStopCompleteWaitMs),
468 [this] { return !awaiting_event_loop_termination_; });
469 if (!status) {
470 LOG(ERROR) << "Legacy HAL stop failed or timed out";
471 return WIFI_ERROR_UNKNOWN;
472 }
473 LOG(DEBUG) << "Legacy HAL stop complete";
Roshan Pius11f93032016-12-09 10:26:17 -0800474 return WIFI_SUCCESS;
Roshan Piusaabe5752016-09-29 09:03:59 -0700475}
476
Ahmed ElArabawy48229382019-02-07 22:04:53 -0800477bool WifiLegacyHal::isStarted() { return is_started_; }
478
Roshan Pius8c1a67b2021-03-02 10:00:23 -0800479wifi_error WifiLegacyHal::waitForDriverReady() {
480 return global_func_table_.wifi_wait_for_driver_ready();
481}
482
Roshan Piusacededb2017-10-06 14:59:26 -0700483std::pair<wifi_error, std::string> WifiLegacyHal::getDriverVersion(
484 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700485 std::array<char, kMaxVersionStringLength> buffer;
486 buffer.fill(0);
487 wifi_error status = global_func_table_.wifi_get_driver_version(
488 getIfaceHandle(iface_name), buffer.data(), buffer.size());
489 return {status, buffer.data()};
Roshan Pius4b26c832016-10-03 12:49:58 -0700490}
491
Roshan Piusacededb2017-10-06 14:59:26 -0700492std::pair<wifi_error, std::string> WifiLegacyHal::getFirmwareVersion(
493 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700494 std::array<char, kMaxVersionStringLength> buffer;
495 buffer.fill(0);
496 wifi_error status = global_func_table_.wifi_get_firmware_version(
497 getIfaceHandle(iface_name), buffer.data(), buffer.size());
498 return {status, buffer.data()};
Roshan Pius4b26c832016-10-03 12:49:58 -0700499}
500
Roshan Pius3c868522016-10-27 12:43:49 -0700501std::pair<wifi_error, std::vector<uint8_t>>
Roshan Piusabcf78f2017-10-06 16:30:38 -0700502WifiLegacyHal::requestDriverMemoryDump(const std::string& iface_name) {
503 std::vector<uint8_t> driver_dump;
504 on_driver_memory_dump_internal_callback = [&driver_dump](char* buffer,
505 int buffer_size) {
506 driver_dump.insert(driver_dump.end(),
507 reinterpret_cast<uint8_t*>(buffer),
508 reinterpret_cast<uint8_t*>(buffer) + buffer_size);
509 };
510 wifi_error status = global_func_table_.wifi_get_driver_memory_dump(
511 getIfaceHandle(iface_name), {onSyncDriverMemoryDump});
512 on_driver_memory_dump_internal_callback = nullptr;
513 return {status, std::move(driver_dump)};
Roshan Piuscdb77f32016-10-03 14:09:57 -0700514}
515
Roshan Pius3c868522016-10-27 12:43:49 -0700516std::pair<wifi_error, std::vector<uint8_t>>
Roshan Piusacededb2017-10-06 14:59:26 -0700517WifiLegacyHal::requestFirmwareMemoryDump(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700518 std::vector<uint8_t> firmware_dump;
519 on_firmware_memory_dump_internal_callback =
520 [&firmware_dump](char* buffer, int buffer_size) {
521 firmware_dump.insert(
522 firmware_dump.end(), reinterpret_cast<uint8_t*>(buffer),
523 reinterpret_cast<uint8_t*>(buffer) + buffer_size);
524 };
525 wifi_error status = global_func_table_.wifi_get_firmware_memory_dump(
526 getIfaceHandle(iface_name), {onSyncFirmwareMemoryDump});
527 on_firmware_memory_dump_internal_callback = nullptr;
528 return {status, std::move(firmware_dump)};
Roshan Pius0a47c182016-10-28 10:23:00 -0700529}
530
Jimmy Chen1bdf1a72019-12-23 17:53:40 +0200531std::pair<wifi_error, uint64_t> WifiLegacyHal::getSupportedFeatureSet(
Roshan Piusacededb2017-10-06 14:59:26 -0700532 const std::string& iface_name) {
Jimmy Chen2dddd792019-12-23 17:50:39 +0200533 feature_set set = 0, chip_set = 0;
534 wifi_error status = WIFI_SUCCESS;
535
Ahmed ElArabawy95e36b72019-11-15 21:24:53 +0000536 static_assert(sizeof(set) == sizeof(uint64_t),
Roshan Pius200a17d2017-11-01 13:03:35 -0700537 "Some feature_flags can not be represented in output");
Jimmy Chen2dddd792019-12-23 17:50:39 +0200538 wifi_interface_handle iface_handle = getIfaceHandle(iface_name);
539
540 global_func_table_.wifi_get_chip_feature_set(
541 global_handle_, &chip_set); /* ignore error, chip_set will stay 0 */
542
543 if (iface_handle) {
544 status = global_func_table_.wifi_get_supported_feature_set(iface_handle,
545 &set);
546 }
Jimmy Chen1bdf1a72019-12-23 17:53:40 +0200547 return {status, static_cast<uint64_t>(set | chip_set)};
Roshan Pius0a47c182016-10-28 10:23:00 -0700548}
549
550std::pair<wifi_error, PacketFilterCapabilities>
Roshan Piusacededb2017-10-06 14:59:26 -0700551WifiLegacyHal::getPacketFilterCapabilities(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700552 PacketFilterCapabilities caps;
553 wifi_error status = global_func_table_.wifi_get_packet_filter_capabilities(
554 getIfaceHandle(iface_name), &caps.version, &caps.max_len);
555 return {status, caps};
Roshan Pius0a47c182016-10-28 10:23:00 -0700556}
557
Roshan Piusabcf78f2017-10-06 16:30:38 -0700558wifi_error WifiLegacyHal::setPacketFilter(const std::string& iface_name,
559 const std::vector<uint8_t>& program) {
560 return global_func_table_.wifi_set_packet_filter(
561 getIfaceHandle(iface_name), program.data(), program.size());
Roshan Piuscdb77f32016-10-03 14:09:57 -0700562}
563
Bernie Innocenti7e6f71a2018-03-07 00:17:50 +0900564std::pair<wifi_error, std::vector<uint8_t>>
565WifiLegacyHal::readApfPacketFilterData(const std::string& iface_name) {
Bernie Innocenti7e6f71a2018-03-07 00:17:50 +0900566 PacketFilterCapabilities caps;
567 wifi_error status = global_func_table_.wifi_get_packet_filter_capabilities(
568 getIfaceHandle(iface_name), &caps.version, &caps.max_len);
569 if (status != WIFI_SUCCESS) {
570 return {status, {}};
571 }
572
573 // Size the buffer to read the entire program & work memory.
574 std::vector<uint8_t> buffer(caps.max_len);
575
576 status = global_func_table_.wifi_read_packet_filter(
577 getIfaceHandle(iface_name), /*src_offset=*/0, buffer.data(),
578 buffer.size());
579 return {status, move(buffer)};
580}
581
Roshan Pius76ff3022016-10-28 10:33:34 -0700582std::pair<wifi_error, wifi_gscan_capabilities>
Roshan Piusacededb2017-10-06 14:59:26 -0700583WifiLegacyHal::getGscanCapabilities(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700584 wifi_gscan_capabilities caps;
585 wifi_error status = global_func_table_.wifi_get_gscan_capabilities(
586 getIfaceHandle(iface_name), &caps);
587 return {status, caps};
Roshan Pius76ff3022016-10-28 10:33:34 -0700588}
589
590wifi_error WifiLegacyHal::startGscan(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700591 const std::string& iface_name, wifi_request_id id,
Roshan Pius76ff3022016-10-28 10:33:34 -0700592 const wifi_scan_cmd_params& params,
593 const std::function<void(wifi_request_id)>& on_failure_user_callback,
594 const on_gscan_results_callback& on_results_user_callback,
595 const on_gscan_full_result_callback& on_full_result_user_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700596 // If there is already an ongoing background scan, reject new scan requests.
597 if (on_gscan_event_internal_callback ||
598 on_gscan_full_result_internal_callback) {
599 return WIFI_ERROR_NOT_AVAILABLE;
Roshan Pius76ff3022016-10-28 10:33:34 -0700600 }
Roshan Pius76ff3022016-10-28 10:33:34 -0700601
Roshan Piusabcf78f2017-10-06 16:30:38 -0700602 // This callback will be used to either trigger |on_results_user_callback|
603 // or |on_failure_user_callback|.
604 on_gscan_event_internal_callback =
605 [iface_name, on_failure_user_callback, on_results_user_callback, this](
606 wifi_request_id id, wifi_scan_event event) {
607 switch (event) {
608 case WIFI_SCAN_RESULTS_AVAILABLE:
609 case WIFI_SCAN_THRESHOLD_NUM_SCANS:
610 case WIFI_SCAN_THRESHOLD_PERCENT: {
611 wifi_error status;
612 std::vector<wifi_cached_scan_results> cached_scan_results;
613 std::tie(status, cached_scan_results) =
614 getGscanCachedResults(iface_name);
615 if (status == WIFI_SUCCESS) {
616 on_results_user_callback(id, cached_scan_results);
617 return;
618 }
Tomasz Wasilczykb424da72018-11-15 11:52:57 -0800619 FALLTHROUGH_INTENDED;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700620 }
621 // Fall through if failed. Failure to retrieve cached scan
622 // results should trigger a background scan failure.
623 case WIFI_SCAN_FAILED:
624 on_failure_user_callback(id);
625 on_gscan_event_internal_callback = nullptr;
626 on_gscan_full_result_internal_callback = nullptr;
627 return;
628 }
629 LOG(FATAL) << "Unexpected gscan event received: " << event;
630 };
631
632 on_gscan_full_result_internal_callback = [on_full_result_user_callback](
633 wifi_request_id id,
634 wifi_scan_result* result,
635 uint32_t buckets_scanned) {
636 if (result) {
637 on_full_result_user_callback(id, result, buckets_scanned);
638 }
639 };
640
641 wifi_scan_result_handler handler = {onAsyncGscanFullResult,
642 onAsyncGscanEvent};
643 wifi_error status = global_func_table_.wifi_start_gscan(
644 id, getIfaceHandle(iface_name), params, handler);
645 if (status != WIFI_SUCCESS) {
646 on_gscan_event_internal_callback = nullptr;
647 on_gscan_full_result_internal_callback = nullptr;
648 }
649 return status;
Roshan Pius76ff3022016-10-28 10:33:34 -0700650}
651
Roshan Piusabcf78f2017-10-06 16:30:38 -0700652wifi_error WifiLegacyHal::stopGscan(const std::string& iface_name,
653 wifi_request_id id) {
654 // If there is no an ongoing background scan, reject stop requests.
655 // TODO(b/32337212): This needs to be handled by the HIDL object because we
656 // need to return the NOT_STARTED error code.
657 if (!on_gscan_event_internal_callback &&
658 !on_gscan_full_result_internal_callback) {
659 return WIFI_ERROR_NOT_AVAILABLE;
660 }
661 wifi_error status =
662 global_func_table_.wifi_stop_gscan(id, getIfaceHandle(iface_name));
663 // If the request Id is wrong, don't stop the ongoing background scan. Any
664 // other error should be treated as the end of background scan.
665 if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
666 on_gscan_event_internal_callback = nullptr;
667 on_gscan_full_result_internal_callback = nullptr;
668 }
669 return status;
Roshan Pius76ff3022016-10-28 10:33:34 -0700670}
671
672std::pair<wifi_error, std::vector<uint32_t>>
Roshan Piusabcf78f2017-10-06 16:30:38 -0700673WifiLegacyHal::getValidFrequenciesForBand(const std::string& iface_name,
674 wifi_band band) {
675 static_assert(sizeof(uint32_t) >= sizeof(wifi_channel),
676 "Wifi Channel cannot be represented in output");
677 std::vector<uint32_t> freqs;
678 freqs.resize(kMaxGscanFrequenciesForBand);
679 int32_t num_freqs = 0;
680 wifi_error status = global_func_table_.wifi_get_valid_channels(
681 getIfaceHandle(iface_name), band, freqs.size(),
682 reinterpret_cast<wifi_channel*>(freqs.data()), &num_freqs);
683 CHECK(num_freqs >= 0 &&
684 static_cast<uint32_t>(num_freqs) <= kMaxGscanFrequenciesForBand);
685 freqs.resize(num_freqs);
686 return {status, std::move(freqs)};
Roshan Pius76ff3022016-10-28 10:33:34 -0700687}
688
Roshan Piusabcf78f2017-10-06 16:30:38 -0700689wifi_error WifiLegacyHal::setDfsFlag(const std::string& iface_name,
690 bool dfs_on) {
691 return global_func_table_.wifi_set_nodfs_flag(getIfaceHandle(iface_name),
692 dfs_on ? 0 : 1);
Roshan Pius08d1df42017-04-19 23:11:07 -0700693}
694
Roshan Piusabcf78f2017-10-06 16:30:38 -0700695wifi_error WifiLegacyHal::enableLinkLayerStats(const std::string& iface_name,
696 bool debug) {
697 wifi_link_layer_params params;
698 params.mpdu_size_threshold = kLinkLayerStatsDataMpduSizeThreshold;
699 params.aggressive_statistics_gathering = debug;
700 return global_func_table_.wifi_set_link_stats(getIfaceHandle(iface_name),
701 params);
Roshan Pius7cece412016-10-28 10:38:21 -0700702}
703
Roshan Piusacededb2017-10-06 14:59:26 -0700704wifi_error WifiLegacyHal::disableLinkLayerStats(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700705 // TODO: Do we care about these responses?
706 uint32_t clear_mask_rsp;
707 uint8_t stop_rsp;
708 return global_func_table_.wifi_clear_link_stats(
709 getIfaceHandle(iface_name), 0xFFFFFFFF, &clear_mask_rsp, 1, &stop_rsp);
Roshan Pius7cece412016-10-28 10:38:21 -0700710}
711
Roshan Piusacededb2017-10-06 14:59:26 -0700712std::pair<wifi_error, LinkLayerStats> WifiLegacyHal::getLinkLayerStats(
713 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700714 LinkLayerStats link_stats{};
715 LinkLayerStats* link_stats_ptr = &link_stats;
Roshan Pius7cece412016-10-28 10:38:21 -0700716
Roshan Piusabcf78f2017-10-06 16:30:38 -0700717 on_link_layer_stats_result_internal_callback =
718 [&link_stats_ptr](wifi_request_id /* id */,
719 wifi_iface_stat* iface_stats_ptr, int num_radios,
720 wifi_radio_stat* radio_stats_ptr) {
Sunil Ravib0343e72018-11-13 15:52:00 -0800721 wifi_radio_stat* l_radio_stats_ptr;
Mingguang Xu41242be2021-02-19 18:16:01 -0800722 wifi_peer_info* l_peer_info_stats_ptr;
Sunil Ravib0343e72018-11-13 15:52:00 -0800723
Roshan Piusabcf78f2017-10-06 16:30:38 -0700724 if (iface_stats_ptr != nullptr) {
725 link_stats_ptr->iface = *iface_stats_ptr;
Mingguang Xu41242be2021-02-19 18:16:01 -0800726 l_peer_info_stats_ptr = iface_stats_ptr->peer_info;
727 for (uint32_t i = 0; i < iface_stats_ptr->num_peers; i++) {
728 WifiPeerInfo peer;
729 peer.peer_info = *l_peer_info_stats_ptr;
730 if (l_peer_info_stats_ptr->num_rate > 0) {
731 /* Copy the rate stats */
732 peer.rate_stats.assign(
733 l_peer_info_stats_ptr->rate_stats,
734 l_peer_info_stats_ptr->rate_stats +
735 l_peer_info_stats_ptr->num_rate);
736 }
737 peer.peer_info.num_rate = 0;
738 link_stats_ptr->peers.push_back(peer);
739 l_peer_info_stats_ptr =
740 (wifi_peer_info*)((u8*)l_peer_info_stats_ptr +
741 sizeof(wifi_peer_info) +
742 (sizeof(wifi_rate_stat) *
743 l_peer_info_stats_ptr->num_rate));
744 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700745 link_stats_ptr->iface.num_peers = 0;
746 } else {
747 LOG(ERROR) << "Invalid iface stats in link layer stats";
748 }
749 if (num_radios <= 0 || radio_stats_ptr == nullptr) {
750 LOG(ERROR) << "Invalid radio stats in link layer stats";
751 return;
752 }
Sunil Ravib0343e72018-11-13 15:52:00 -0800753 l_radio_stats_ptr = radio_stats_ptr;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700754 for (int i = 0; i < num_radios; i++) {
755 LinkLayerRadioStats radio;
Sunil Ravib0343e72018-11-13 15:52:00 -0800756
757 radio.stats = *l_radio_stats_ptr;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700758 // Copy over the tx level array to the separate vector.
Sunil Ravib0343e72018-11-13 15:52:00 -0800759 if (l_radio_stats_ptr->num_tx_levels > 0 &&
760 l_radio_stats_ptr->tx_time_per_levels != nullptr) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700761 radio.tx_time_per_levels.assign(
Sunil Ravib0343e72018-11-13 15:52:00 -0800762 l_radio_stats_ptr->tx_time_per_levels,
763 l_radio_stats_ptr->tx_time_per_levels +
764 l_radio_stats_ptr->num_tx_levels);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700765 }
766 radio.stats.num_tx_levels = 0;
767 radio.stats.tx_time_per_levels = nullptr;
Sunil Ravib0343e72018-11-13 15:52:00 -0800768 /* Copy over the channel stat to separate vector */
769 if (l_radio_stats_ptr->num_channels > 0) {
770 /* Copy the channel stats */
771 radio.channel_stats.assign(
772 l_radio_stats_ptr->channels,
773 l_radio_stats_ptr->channels +
774 l_radio_stats_ptr->num_channels);
775 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700776 link_stats_ptr->radios.push_back(radio);
Sunil Ravib0343e72018-11-13 15:52:00 -0800777 l_radio_stats_ptr =
778 (wifi_radio_stat*)((u8*)l_radio_stats_ptr +
779 sizeof(wifi_radio_stat) +
780 (sizeof(wifi_channel_stat) *
781 l_radio_stats_ptr->num_channels));
Roshan Piusabcf78f2017-10-06 16:30:38 -0700782 }
783 };
Roshan Pius7cece412016-10-28 10:38:21 -0700784
Roshan Piusabcf78f2017-10-06 16:30:38 -0700785 wifi_error status = global_func_table_.wifi_get_link_stats(
786 0, getIfaceHandle(iface_name), {onSyncLinkLayerStatsResult});
787 on_link_layer_stats_result_internal_callback = nullptr;
788 return {status, link_stats};
Roshan Pius7cece412016-10-28 10:38:21 -0700789}
790
Roshan Piusd4767542016-12-06 10:04:05 -0800791wifi_error WifiLegacyHal::startRssiMonitoring(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700792 const std::string& iface_name, wifi_request_id id, int8_t max_rssi,
Roshan Piusd4767542016-12-06 10:04:05 -0800793 int8_t min_rssi,
794 const on_rssi_threshold_breached_callback&
795 on_threshold_breached_user_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700796 if (on_rssi_threshold_breached_internal_callback) {
797 return WIFI_ERROR_NOT_AVAILABLE;
798 }
799 on_rssi_threshold_breached_internal_callback =
800 [on_threshold_breached_user_callback](wifi_request_id id,
801 uint8_t* bssid_ptr, int8_t rssi) {
802 if (!bssid_ptr) {
803 return;
804 }
805 std::array<uint8_t, 6> bssid_arr;
806 // |bssid_ptr| pointer is assumed to have 6 bytes for the mac
807 // address.
808 std::copy(bssid_ptr, bssid_ptr + 6, std::begin(bssid_arr));
809 on_threshold_breached_user_callback(id, bssid_arr, rssi);
810 };
811 wifi_error status = global_func_table_.wifi_start_rssi_monitoring(
812 id, getIfaceHandle(iface_name), max_rssi, min_rssi,
813 {onAsyncRssiThresholdBreached});
814 if (status != WIFI_SUCCESS) {
815 on_rssi_threshold_breached_internal_callback = nullptr;
816 }
817 return status;
Roshan Piusd4767542016-12-06 10:04:05 -0800818}
819
Roshan Piusabcf78f2017-10-06 16:30:38 -0700820wifi_error WifiLegacyHal::stopRssiMonitoring(const std::string& iface_name,
821 wifi_request_id id) {
822 if (!on_rssi_threshold_breached_internal_callback) {
823 return WIFI_ERROR_NOT_AVAILABLE;
824 }
825 wifi_error status = global_func_table_.wifi_stop_rssi_monitoring(
826 id, getIfaceHandle(iface_name));
827 // If the request Id is wrong, don't stop the ongoing rssi monitoring. Any
828 // other error should be treated as the end of background scan.
829 if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
830 on_rssi_threshold_breached_internal_callback = nullptr;
831 }
832 return status;
Roshan Piusd4767542016-12-06 10:04:05 -0800833}
834
Roshan Pius26801cb2016-12-13 14:25:45 -0800835std::pair<wifi_error, wifi_roaming_capabilities>
Roshan Piusacededb2017-10-06 14:59:26 -0700836WifiLegacyHal::getRoamingCapabilities(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700837 wifi_roaming_capabilities caps;
838 wifi_error status = global_func_table_.wifi_get_roaming_capabilities(
839 getIfaceHandle(iface_name), &caps);
840 return {status, caps};
Roshan Pius26801cb2016-12-13 14:25:45 -0800841}
842
Roshan Piusabcf78f2017-10-06 16:30:38 -0700843wifi_error WifiLegacyHal::configureRoaming(const std::string& iface_name,
844 const wifi_roaming_config& config) {
845 wifi_roaming_config config_internal = config;
846 return global_func_table_.wifi_configure_roaming(getIfaceHandle(iface_name),
847 &config_internal);
Roshan Piusaf727c02017-01-11 15:37:25 -0800848}
849
Roshan Piusabcf78f2017-10-06 16:30:38 -0700850wifi_error WifiLegacyHal::enableFirmwareRoaming(const std::string& iface_name,
851 fw_roaming_state_t state) {
852 return global_func_table_.wifi_enable_firmware_roaming(
853 getIfaceHandle(iface_name), state);
Roshan Pius26801cb2016-12-13 14:25:45 -0800854}
855
Roshan Piusabcf78f2017-10-06 16:30:38 -0700856wifi_error WifiLegacyHal::configureNdOffload(const std::string& iface_name,
857 bool enable) {
858 return global_func_table_.wifi_configure_nd_offload(
859 getIfaceHandle(iface_name), enable);
Roshan Pius26801cb2016-12-13 14:25:45 -0800860}
861
Roshan Pius9a9869a2017-01-11 16:42:16 -0800862wifi_error WifiLegacyHal::startSendingOffloadedPacket(
Ahmed ElArabawyffbad182019-03-05 17:38:06 -0800863 const std::string& iface_name, uint32_t cmd_id, uint16_t ether_type,
Roshan Pius9a9869a2017-01-11 16:42:16 -0800864 const std::vector<uint8_t>& ip_packet_data,
865 const std::array<uint8_t, 6>& src_address,
Roshan Piusabcf78f2017-10-06 16:30:38 -0700866 const std::array<uint8_t, 6>& dst_address, uint32_t period_in_ms) {
867 std::vector<uint8_t> ip_packet_data_internal(ip_packet_data);
868 std::vector<uint8_t> src_address_internal(
869 src_address.data(), src_address.data() + src_address.size());
870 std::vector<uint8_t> dst_address_internal(
871 dst_address.data(), dst_address.data() + dst_address.size());
872 return global_func_table_.wifi_start_sending_offloaded_packet(
Ahmed ElArabawyffbad182019-03-05 17:38:06 -0800873 cmd_id, getIfaceHandle(iface_name), ether_type,
874 ip_packet_data_internal.data(), ip_packet_data_internal.size(),
875 src_address_internal.data(), dst_address_internal.data(), period_in_ms);
Roshan Pius9a9869a2017-01-11 16:42:16 -0800876}
877
Roshan Piusacededb2017-10-06 14:59:26 -0700878wifi_error WifiLegacyHal::stopSendingOffloadedPacket(
879 const std::string& iface_name, uint32_t cmd_id) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700880 return global_func_table_.wifi_stop_sending_offloaded_packet(
881 cmd_id, getIfaceHandle(iface_name));
Roshan Pius9a9869a2017-01-11 16:42:16 -0800882}
883
Roshan Piusabcf78f2017-10-06 16:30:38 -0700884wifi_error WifiLegacyHal::selectTxPowerScenario(const std::string& iface_name,
885 wifi_power_scenario scenario) {
886 return global_func_table_.wifi_select_tx_power_scenario(
887 getIfaceHandle(iface_name), scenario);
Roshan Pius8184d212017-07-11 08:59:29 -0700888}
889
Roshan Piusacededb2017-10-06 14:59:26 -0700890wifi_error WifiLegacyHal::resetTxPowerScenario(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700891 return global_func_table_.wifi_reset_tx_power_scenario(
892 getIfaceHandle(iface_name));
Roshan Pius8184d212017-07-11 08:59:29 -0700893}
894
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700895wifi_error WifiLegacyHal::setLatencyMode(const std::string& iface_name,
896 wifi_latency_mode mode) {
897 return global_func_table_.wifi_set_latency_mode(getIfaceHandle(iface_name),
898 mode);
899}
900
Kumar Anandf2747e02020-01-10 16:49:13 -0800901wifi_error WifiLegacyHal::setThermalMitigationMode(wifi_thermal_mode mode,
902 uint32_t completion_window) {
Kumar Anand913d5602019-12-18 16:02:37 -0800903 return global_func_table_.wifi_set_thermal_mitigation_mode(
Kumar Anandf2747e02020-01-10 16:49:13 -0800904 global_handle_, mode, completion_window);
Kumar Anand913d5602019-12-18 16:02:37 -0800905}
906
Ahmed ElArabawya1d13652020-01-29 09:22:28 -0800907wifi_error WifiLegacyHal::setDscpToAccessCategoryMapping(
908 uint32_t start, uint32_t end, uint32_t access_category) {
909 return global_func_table_.wifi_map_dscp_access_category(
910 global_handle_, start, end, access_category);
911}
912
913wifi_error WifiLegacyHal::resetDscpToAccessCategoryMapping() {
914 return global_func_table_.wifi_reset_dscp_mapping(global_handle_);
915}
916
Roshan Piusacededb2017-10-06 14:59:26 -0700917std::pair<wifi_error, uint32_t> WifiLegacyHal::getLoggerSupportedFeatureSet(
918 const std::string& iface_name) {
Jimmy Chen2dddd792019-12-23 17:50:39 +0200919 uint32_t supported_feature_flags = 0;
920 wifi_error status = WIFI_SUCCESS;
921
922 wifi_interface_handle iface_handle = getIfaceHandle(iface_name);
923
924 if (iface_handle) {
925 status = global_func_table_.wifi_get_logger_supported_feature_set(
926 iface_handle, &supported_feature_flags);
927 }
Roshan Pius200a17d2017-11-01 13:03:35 -0700928 return {status, supported_feature_flags};
Roshan Pius8714a3e2016-10-28 10:43:51 -0700929}
930
Roshan Piusacededb2017-10-06 14:59:26 -0700931wifi_error WifiLegacyHal::startPktFateMonitoring(
932 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700933 return global_func_table_.wifi_start_pkt_fate_monitoring(
934 getIfaceHandle(iface_name));
Roshan Pius8714a3e2016-10-28 10:43:51 -0700935}
936
Roshan Piusabcf78f2017-10-06 16:30:38 -0700937std::pair<wifi_error, std::vector<wifi_tx_report>> WifiLegacyHal::getTxPktFates(
938 const std::string& iface_name) {
939 std::vector<wifi_tx_report> tx_pkt_fates;
940 tx_pkt_fates.resize(MAX_FATE_LOG_LEN);
941 size_t num_fates = 0;
942 wifi_error status = global_func_table_.wifi_get_tx_pkt_fates(
943 getIfaceHandle(iface_name), tx_pkt_fates.data(), tx_pkt_fates.size(),
944 &num_fates);
945 CHECK(num_fates <= MAX_FATE_LOG_LEN);
946 tx_pkt_fates.resize(num_fates);
947 return {status, std::move(tx_pkt_fates)};
Roshan Pius8714a3e2016-10-28 10:43:51 -0700948}
949
Roshan Piusabcf78f2017-10-06 16:30:38 -0700950std::pair<wifi_error, std::vector<wifi_rx_report>> WifiLegacyHal::getRxPktFates(
951 const std::string& iface_name) {
952 std::vector<wifi_rx_report> rx_pkt_fates;
953 rx_pkt_fates.resize(MAX_FATE_LOG_LEN);
954 size_t num_fates = 0;
955 wifi_error status = global_func_table_.wifi_get_rx_pkt_fates(
956 getIfaceHandle(iface_name), rx_pkt_fates.data(), rx_pkt_fates.size(),
957 &num_fates);
958 CHECK(num_fates <= MAX_FATE_LOG_LEN);
959 rx_pkt_fates.resize(num_fates);
960 return {status, std::move(rx_pkt_fates)};
Roshan Pius8714a3e2016-10-28 10:43:51 -0700961}
962
Roshan Piusacededb2017-10-06 14:59:26 -0700963std::pair<wifi_error, WakeReasonStats> WifiLegacyHal::getWakeReasonStats(
964 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700965 WakeReasonStats stats;
966 stats.cmd_event_wake_cnt.resize(kMaxWakeReasonStatsArraySize);
967 stats.driver_fw_local_wake_cnt.resize(kMaxWakeReasonStatsArraySize);
Roshan Pius8714a3e2016-10-28 10:43:51 -0700968
Roshan Piusabcf78f2017-10-06 16:30:38 -0700969 // This legacy struct needs separate memory to store the variable sized wake
970 // reason types.
971 stats.wake_reason_cnt.cmd_event_wake_cnt =
972 reinterpret_cast<int32_t*>(stats.cmd_event_wake_cnt.data());
973 stats.wake_reason_cnt.cmd_event_wake_cnt_sz =
974 stats.cmd_event_wake_cnt.size();
975 stats.wake_reason_cnt.cmd_event_wake_cnt_used = 0;
976 stats.wake_reason_cnt.driver_fw_local_wake_cnt =
977 reinterpret_cast<int32_t*>(stats.driver_fw_local_wake_cnt.data());
978 stats.wake_reason_cnt.driver_fw_local_wake_cnt_sz =
979 stats.driver_fw_local_wake_cnt.size();
980 stats.wake_reason_cnt.driver_fw_local_wake_cnt_used = 0;
Roshan Pius8714a3e2016-10-28 10:43:51 -0700981
Roshan Piusabcf78f2017-10-06 16:30:38 -0700982 wifi_error status = global_func_table_.wifi_get_wake_reason_stats(
983 getIfaceHandle(iface_name), &stats.wake_reason_cnt);
Roshan Pius8714a3e2016-10-28 10:43:51 -0700984
Roshan Piusabcf78f2017-10-06 16:30:38 -0700985 CHECK(
986 stats.wake_reason_cnt.cmd_event_wake_cnt_used >= 0 &&
Roshan Pius8714a3e2016-10-28 10:43:51 -0700987 static_cast<uint32_t>(stats.wake_reason_cnt.cmd_event_wake_cnt_used) <=
988 kMaxWakeReasonStatsArraySize);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700989 stats.cmd_event_wake_cnt.resize(
990 stats.wake_reason_cnt.cmd_event_wake_cnt_used);
991 stats.wake_reason_cnt.cmd_event_wake_cnt = nullptr;
Roshan Pius8714a3e2016-10-28 10:43:51 -0700992
Roshan Piusabcf78f2017-10-06 16:30:38 -0700993 CHECK(stats.wake_reason_cnt.driver_fw_local_wake_cnt_used >= 0 &&
994 static_cast<uint32_t>(
995 stats.wake_reason_cnt.driver_fw_local_wake_cnt_used) <=
996 kMaxWakeReasonStatsArraySize);
997 stats.driver_fw_local_wake_cnt.resize(
998 stats.wake_reason_cnt.driver_fw_local_wake_cnt_used);
999 stats.wake_reason_cnt.driver_fw_local_wake_cnt = nullptr;
Roshan Pius8714a3e2016-10-28 10:43:51 -07001000
Roshan Piusabcf78f2017-10-06 16:30:38 -07001001 return {status, stats};
Roshan Pius8714a3e2016-10-28 10:43:51 -07001002}
1003
1004wifi_error WifiLegacyHal::registerRingBufferCallbackHandler(
Roshan Piusacededb2017-10-06 14:59:26 -07001005 const std::string& iface_name,
Roshan Pius8714a3e2016-10-28 10:43:51 -07001006 const on_ring_buffer_data_callback& on_user_data_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001007 if (on_ring_buffer_data_internal_callback) {
1008 return WIFI_ERROR_NOT_AVAILABLE;
Roshan Pius8714a3e2016-10-28 10:43:51 -07001009 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001010 on_ring_buffer_data_internal_callback =
1011 [on_user_data_callback](char* ring_name, char* buffer, int buffer_size,
1012 wifi_ring_buffer_status* status) {
1013 if (status && buffer) {
1014 std::vector<uint8_t> buffer_vector(
1015 reinterpret_cast<uint8_t*>(buffer),
1016 reinterpret_cast<uint8_t*>(buffer) + buffer_size);
1017 on_user_data_callback(ring_name, buffer_vector, *status);
1018 }
1019 };
1020 wifi_error status = global_func_table_.wifi_set_log_handler(
1021 0, getIfaceHandle(iface_name), {onAsyncRingBufferData});
1022 if (status != WIFI_SUCCESS) {
1023 on_ring_buffer_data_internal_callback = nullptr;
1024 }
1025 return status;
Roshan Piusadc87cb2016-12-14 18:02:56 -08001026}
1027
Roshan Piusacededb2017-10-06 14:59:26 -07001028wifi_error WifiLegacyHal::deregisterRingBufferCallbackHandler(
1029 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001030 if (!on_ring_buffer_data_internal_callback) {
1031 return WIFI_ERROR_NOT_AVAILABLE;
1032 }
1033 on_ring_buffer_data_internal_callback = nullptr;
1034 return global_func_table_.wifi_reset_log_handler(
1035 0, getIfaceHandle(iface_name));
Roshan Pius8714a3e2016-10-28 10:43:51 -07001036}
1037
1038std::pair<wifi_error, std::vector<wifi_ring_buffer_status>>
Roshan Piusacededb2017-10-06 14:59:26 -07001039WifiLegacyHal::getRingBuffersStatus(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001040 std::vector<wifi_ring_buffer_status> ring_buffers_status;
1041 ring_buffers_status.resize(kMaxRingBuffers);
1042 uint32_t num_rings = kMaxRingBuffers;
1043 wifi_error status = global_func_table_.wifi_get_ring_buffers_status(
1044 getIfaceHandle(iface_name), &num_rings, ring_buffers_status.data());
1045 CHECK(num_rings <= kMaxRingBuffers);
1046 ring_buffers_status.resize(num_rings);
1047 return {status, std::move(ring_buffers_status)};
Roshan Pius8714a3e2016-10-28 10:43:51 -07001048}
1049
Roshan Piusabcf78f2017-10-06 16:30:38 -07001050wifi_error WifiLegacyHal::startRingBufferLogging(const std::string& iface_name,
1051 const std::string& ring_name,
1052 uint32_t verbose_level,
1053 uint32_t max_interval_sec,
1054 uint32_t min_data_size) {
1055 return global_func_table_.wifi_start_logging(
1056 getIfaceHandle(iface_name), verbose_level, 0, max_interval_sec,
1057 min_data_size, makeCharVec(ring_name).data());
Roshan Pius8714a3e2016-10-28 10:43:51 -07001058}
1059
Roshan Piusabcf78f2017-10-06 16:30:38 -07001060wifi_error WifiLegacyHal::getRingBufferData(const std::string& iface_name,
1061 const std::string& ring_name) {
1062 return global_func_table_.wifi_get_ring_data(getIfaceHandle(iface_name),
1063 makeCharVec(ring_name).data());
Roshan Pius8714a3e2016-10-28 10:43:51 -07001064}
1065
Roshan Pius203cb032016-12-14 17:41:20 -08001066wifi_error WifiLegacyHal::registerErrorAlertCallbackHandler(
Roshan Piusacededb2017-10-06 14:59:26 -07001067 const std::string& iface_name,
Roshan Pius203cb032016-12-14 17:41:20 -08001068 const on_error_alert_callback& on_user_alert_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001069 if (on_error_alert_internal_callback) {
1070 return WIFI_ERROR_NOT_AVAILABLE;
Roshan Pius203cb032016-12-14 17:41:20 -08001071 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001072 on_error_alert_internal_callback = [on_user_alert_callback](
1073 wifi_request_id id, char* buffer,
1074 int buffer_size, int err_code) {
1075 if (buffer) {
1076 CHECK(id == 0);
1077 on_user_alert_callback(
1078 err_code,
1079 std::vector<uint8_t>(
1080 reinterpret_cast<uint8_t*>(buffer),
1081 reinterpret_cast<uint8_t*>(buffer) + buffer_size));
1082 }
1083 };
1084 wifi_error status = global_func_table_.wifi_set_alert_handler(
1085 0, getIfaceHandle(iface_name), {onAsyncErrorAlert});
1086 if (status != WIFI_SUCCESS) {
1087 on_error_alert_internal_callback = nullptr;
1088 }
1089 return status;
Roshan Pius203cb032016-12-14 17:41:20 -08001090}
1091
Roshan Piusacededb2017-10-06 14:59:26 -07001092wifi_error WifiLegacyHal::deregisterErrorAlertCallbackHandler(
1093 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001094 if (!on_error_alert_internal_callback) {
1095 return WIFI_ERROR_NOT_AVAILABLE;
1096 }
1097 on_error_alert_internal_callback = nullptr;
1098 return global_func_table_.wifi_reset_alert_handler(
1099 0, getIfaceHandle(iface_name));
Roshan Pius203cb032016-12-14 17:41:20 -08001100}
1101
Roshan Pius01f08772018-01-22 17:56:06 -08001102wifi_error WifiLegacyHal::registerRadioModeChangeCallbackHandler(
1103 const std::string& iface_name,
1104 const on_radio_mode_change_callback& on_user_change_callback) {
1105 if (on_radio_mode_change_internal_callback) {
1106 return WIFI_ERROR_NOT_AVAILABLE;
1107 }
1108 on_radio_mode_change_internal_callback = [on_user_change_callback](
1109 wifi_request_id /* id */,
1110 uint32_t num_macs,
1111 wifi_mac_info* mac_infos_arr) {
1112 if (num_macs > 0 && mac_infos_arr) {
1113 std::vector<WifiMacInfo> mac_infos_vec;
1114 for (uint32_t i = 0; i < num_macs; i++) {
1115 WifiMacInfo mac_info;
1116 mac_info.wlan_mac_id = mac_infos_arr[i].wlan_mac_id;
1117 mac_info.mac_band = mac_infos_arr[i].mac_band;
1118 for (int32_t j = 0; j < mac_infos_arr[i].num_iface; j++) {
1119 WifiIfaceInfo iface_info;
1120 iface_info.name = mac_infos_arr[i].iface_info[j].iface_name;
1121 iface_info.channel = mac_infos_arr[i].iface_info[j].channel;
1122 mac_info.iface_infos.push_back(iface_info);
1123 }
1124 mac_infos_vec.push_back(mac_info);
1125 }
1126 on_user_change_callback(mac_infos_vec);
1127 }
1128 };
1129 wifi_error status = global_func_table_.wifi_set_radio_mode_change_handler(
1130 0, getIfaceHandle(iface_name), {onAsyncRadioModeChange});
1131 if (status != WIFI_SUCCESS) {
1132 on_radio_mode_change_internal_callback = nullptr;
1133 }
1134 return status;
1135}
1136
Ahmed ElArabawy2134bf72020-06-18 15:07:12 -07001137wifi_error WifiLegacyHal::registerSubsystemRestartCallbackHandler(
1138 const on_subsystem_restart_callback& on_restart_callback) {
1139 if (on_subsystem_restart_internal_callback) {
1140 return WIFI_ERROR_NOT_AVAILABLE;
1141 }
1142 on_subsystem_restart_internal_callback =
1143 [on_restart_callback](const char* error) {
1144 on_restart_callback(error);
1145 };
1146 wifi_error status = global_func_table_.wifi_set_subsystem_restart_handler(
1147 global_handle_, {onAsyncSubsystemRestart});
1148 if (status != WIFI_SUCCESS) {
1149 on_subsystem_restart_internal_callback = nullptr;
1150 }
1151 return status;
1152}
1153
Roshan Piusd8e915a2016-10-28 11:23:11 -07001154wifi_error WifiLegacyHal::startRttRangeRequest(
Roshan Piusabcf78f2017-10-06 16:30:38 -07001155 const std::string& iface_name, wifi_request_id id,
Roshan Piusd8e915a2016-10-28 11:23:11 -07001156 const std::vector<wifi_rtt_config>& rtt_configs,
1157 const on_rtt_results_callback& on_results_user_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001158 if (on_rtt_results_internal_callback) {
1159 return WIFI_ERROR_NOT_AVAILABLE;
Roshan Piusd8e915a2016-10-28 11:23:11 -07001160 }
Roshan Piusd8e915a2016-10-28 11:23:11 -07001161
Roshan Piusabcf78f2017-10-06 16:30:38 -07001162 on_rtt_results_internal_callback =
1163 [on_results_user_callback](wifi_request_id id, unsigned num_results,
1164 wifi_rtt_result* rtt_results[]) {
1165 if (num_results > 0 && !rtt_results) {
1166 LOG(ERROR) << "Unexpected nullptr in RTT results";
1167 return;
1168 }
1169 std::vector<const wifi_rtt_result*> rtt_results_vec;
1170 std::copy_if(rtt_results, rtt_results + num_results,
1171 back_inserter(rtt_results_vec),
1172 [](wifi_rtt_result* rtt_result) {
1173 return rtt_result != nullptr;
1174 });
1175 on_results_user_callback(id, rtt_results_vec);
1176 };
1177
1178 std::vector<wifi_rtt_config> rtt_configs_internal(rtt_configs);
1179 wifi_error status = global_func_table_.wifi_rtt_range_request(
1180 id, getIfaceHandle(iface_name), rtt_configs.size(),
1181 rtt_configs_internal.data(), {onAsyncRttResults});
1182 if (status != WIFI_SUCCESS) {
1183 on_rtt_results_internal_callback = nullptr;
1184 }
1185 return status;
Roshan Piusd8e915a2016-10-28 11:23:11 -07001186}
1187
1188wifi_error WifiLegacyHal::cancelRttRangeRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001189 const std::string& iface_name, wifi_request_id id,
1190 const std::vector<std::array<uint8_t, 6>>& mac_addrs) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001191 if (!on_rtt_results_internal_callback) {
1192 return WIFI_ERROR_NOT_AVAILABLE;
1193 }
1194 static_assert(sizeof(mac_addr) == sizeof(std::array<uint8_t, 6>),
1195 "MAC address size mismatch");
1196 // TODO: How do we handle partial cancels (i.e only a subset of enabled mac
1197 // addressed are cancelled).
1198 std::vector<std::array<uint8_t, 6>> mac_addrs_internal(mac_addrs);
1199 wifi_error status = global_func_table_.wifi_rtt_range_cancel(
1200 id, getIfaceHandle(iface_name), mac_addrs.size(),
1201 reinterpret_cast<mac_addr*>(mac_addrs_internal.data()));
1202 // If the request Id is wrong, don't stop the ongoing range request. Any
1203 // other error should be treated as the end of rtt ranging.
1204 if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
1205 on_rtt_results_internal_callback = nullptr;
1206 }
1207 return status;
Roshan Piusd8e915a2016-10-28 11:23:11 -07001208}
1209
Roshan Piusabcf78f2017-10-06 16:30:38 -07001210std::pair<wifi_error, wifi_rtt_capabilities> WifiLegacyHal::getRttCapabilities(
1211 const std::string& iface_name) {
1212 wifi_rtt_capabilities rtt_caps;
1213 wifi_error status = global_func_table_.wifi_get_rtt_capabilities(
1214 getIfaceHandle(iface_name), &rtt_caps);
1215 return {status, rtt_caps};
Roshan Piusd8e915a2016-10-28 11:23:11 -07001216}
1217
Roshan Piusacededb2017-10-06 14:59:26 -07001218std::pair<wifi_error, wifi_rtt_responder> WifiLegacyHal::getRttResponderInfo(
1219 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001220 wifi_rtt_responder rtt_responder;
1221 wifi_error status = global_func_table_.wifi_rtt_get_responder_info(
1222 getIfaceHandle(iface_name), &rtt_responder);
1223 return {status, rtt_responder};
Roshan Piusd8e915a2016-10-28 11:23:11 -07001224}
1225
1226wifi_error WifiLegacyHal::enableRttResponder(
Roshan Piusabcf78f2017-10-06 16:30:38 -07001227 const std::string& iface_name, wifi_request_id id,
1228 const wifi_channel_info& channel_hint, uint32_t max_duration_secs,
Roshan Piusd8e915a2016-10-28 11:23:11 -07001229 const wifi_rtt_responder& info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001230 wifi_rtt_responder info_internal(info);
1231 return global_func_table_.wifi_enable_responder(
1232 id, getIfaceHandle(iface_name), channel_hint, max_duration_secs,
1233 &info_internal);
Roshan Piusd8e915a2016-10-28 11:23:11 -07001234}
1235
Roshan Piusabcf78f2017-10-06 16:30:38 -07001236wifi_error WifiLegacyHal::disableRttResponder(const std::string& iface_name,
1237 wifi_request_id id) {
1238 return global_func_table_.wifi_disable_responder(
1239 id, getIfaceHandle(iface_name));
Roshan Piusd8e915a2016-10-28 11:23:11 -07001240}
1241
Roshan Piusabcf78f2017-10-06 16:30:38 -07001242wifi_error WifiLegacyHal::setRttLci(const std::string& iface_name,
1243 wifi_request_id id,
1244 const wifi_lci_information& info) {
1245 wifi_lci_information info_internal(info);
1246 return global_func_table_.wifi_set_lci(id, getIfaceHandle(iface_name),
1247 &info_internal);
Roshan Piusd8e915a2016-10-28 11:23:11 -07001248}
1249
Roshan Piusabcf78f2017-10-06 16:30:38 -07001250wifi_error WifiLegacyHal::setRttLcr(const std::string& iface_name,
1251 wifi_request_id id,
1252 const wifi_lcr_information& info) {
1253 wifi_lcr_information info_internal(info);
1254 return global_func_table_.wifi_set_lcr(id, getIfaceHandle(iface_name),
1255 &info_internal);
Roshan Piusd8e915a2016-10-28 11:23:11 -07001256}
1257
Roshan Pius23012092016-10-28 11:27:40 -07001258wifi_error WifiLegacyHal::nanRegisterCallbackHandlers(
Roshan Piusacededb2017-10-06 14:59:26 -07001259 const std::string& iface_name, const NanCallbackHandlers& user_callbacks) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001260 on_nan_notify_response_user_callback = user_callbacks.on_notify_response;
1261 on_nan_event_publish_terminated_user_callback =
1262 user_callbacks.on_event_publish_terminated;
1263 on_nan_event_match_user_callback = user_callbacks.on_event_match;
1264 on_nan_event_match_expired_user_callback =
1265 user_callbacks.on_event_match_expired;
1266 on_nan_event_subscribe_terminated_user_callback =
1267 user_callbacks.on_event_subscribe_terminated;
1268 on_nan_event_followup_user_callback = user_callbacks.on_event_followup;
1269 on_nan_event_disc_eng_event_user_callback =
1270 user_callbacks.on_event_disc_eng_event;
1271 on_nan_event_disabled_user_callback = user_callbacks.on_event_disabled;
1272 on_nan_event_tca_user_callback = user_callbacks.on_event_tca;
1273 on_nan_event_beacon_sdf_payload_user_callback =
1274 user_callbacks.on_event_beacon_sdf_payload;
1275 on_nan_event_data_path_request_user_callback =
1276 user_callbacks.on_event_data_path_request;
1277 on_nan_event_data_path_confirm_user_callback =
1278 user_callbacks.on_event_data_path_confirm;
1279 on_nan_event_data_path_end_user_callback =
1280 user_callbacks.on_event_data_path_end;
1281 on_nan_event_transmit_follow_up_user_callback =
1282 user_callbacks.on_event_transmit_follow_up;
1283 on_nan_event_range_request_user_callback =
1284 user_callbacks.on_event_range_request;
1285 on_nan_event_range_report_user_callback =
1286 user_callbacks.on_event_range_report;
Etan Cohen1bf15f12017-12-12 16:15:16 -08001287 on_nan_event_schedule_update_user_callback =
1288 user_callbacks.on_event_schedule_update;
Roshan Pius23012092016-10-28 11:27:40 -07001289
Roshan Piusabcf78f2017-10-06 16:30:38 -07001290 return global_func_table_.wifi_nan_register_handler(
1291 getIfaceHandle(iface_name),
1292 {onAysncNanNotifyResponse, onAysncNanEventPublishReplied,
1293 onAysncNanEventPublishTerminated, onAysncNanEventMatch,
1294 onAysncNanEventMatchExpired, onAysncNanEventSubscribeTerminated,
1295 onAysncNanEventFollowup, onAysncNanEventDiscEngEvent,
1296 onAysncNanEventDisabled, onAysncNanEventTca,
1297 onAysncNanEventBeaconSdfPayload, onAysncNanEventDataPathRequest,
1298 onAysncNanEventDataPathConfirm, onAysncNanEventDataPathEnd,
1299 onAysncNanEventTransmitFollowUp, onAysncNanEventRangeRequest,
Etan Cohen1bf15f12017-12-12 16:15:16 -08001300 onAysncNanEventRangeReport, onAsyncNanEventScheduleUpdate});
Roshan Pius23012092016-10-28 11:27:40 -07001301}
1302
Roshan Piusabcf78f2017-10-06 16:30:38 -07001303wifi_error WifiLegacyHal::nanEnableRequest(const std::string& iface_name,
1304 transaction_id id,
1305 const NanEnableRequest& msg) {
1306 NanEnableRequest msg_internal(msg);
1307 return global_func_table_.wifi_nan_enable_request(
1308 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001309}
1310
Roshan Piusabcf78f2017-10-06 16:30:38 -07001311wifi_error WifiLegacyHal::nanDisableRequest(const std::string& iface_name,
1312 transaction_id id) {
1313 return global_func_table_.wifi_nan_disable_request(
1314 id, getIfaceHandle(iface_name));
Roshan Pius23012092016-10-28 11:27:40 -07001315}
1316
Roshan Piusabcf78f2017-10-06 16:30:38 -07001317wifi_error WifiLegacyHal::nanPublishRequest(const std::string& iface_name,
1318 transaction_id id,
1319 const NanPublishRequest& msg) {
1320 NanPublishRequest msg_internal(msg);
1321 return global_func_table_.wifi_nan_publish_request(
1322 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001323}
1324
1325wifi_error WifiLegacyHal::nanPublishCancelRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001326 const std::string& iface_name, transaction_id id,
1327 const NanPublishCancelRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001328 NanPublishCancelRequest msg_internal(msg);
1329 return global_func_table_.wifi_nan_publish_cancel_request(
1330 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001331}
1332
Roshan Piusabcf78f2017-10-06 16:30:38 -07001333wifi_error WifiLegacyHal::nanSubscribeRequest(const std::string& iface_name,
1334 transaction_id id,
1335 const NanSubscribeRequest& msg) {
1336 NanSubscribeRequest msg_internal(msg);
1337 return global_func_table_.wifi_nan_subscribe_request(
1338 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001339}
1340
1341wifi_error WifiLegacyHal::nanSubscribeCancelRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001342 const std::string& iface_name, transaction_id id,
1343 const NanSubscribeCancelRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001344 NanSubscribeCancelRequest msg_internal(msg);
1345 return global_func_table_.wifi_nan_subscribe_cancel_request(
1346 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001347}
1348
1349wifi_error WifiLegacyHal::nanTransmitFollowupRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001350 const std::string& iface_name, transaction_id id,
1351 const NanTransmitFollowupRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001352 NanTransmitFollowupRequest msg_internal(msg);
1353 return global_func_table_.wifi_nan_transmit_followup_request(
1354 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001355}
1356
Roshan Piusabcf78f2017-10-06 16:30:38 -07001357wifi_error WifiLegacyHal::nanStatsRequest(const std::string& iface_name,
1358 transaction_id id,
1359 const NanStatsRequest& msg) {
1360 NanStatsRequest msg_internal(msg);
1361 return global_func_table_.wifi_nan_stats_request(
1362 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001363}
1364
Roshan Piusabcf78f2017-10-06 16:30:38 -07001365wifi_error WifiLegacyHal::nanConfigRequest(const std::string& iface_name,
1366 transaction_id id,
1367 const NanConfigRequest& msg) {
1368 NanConfigRequest msg_internal(msg);
1369 return global_func_table_.wifi_nan_config_request(
1370 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001371}
1372
Roshan Piusabcf78f2017-10-06 16:30:38 -07001373wifi_error WifiLegacyHal::nanTcaRequest(const std::string& iface_name,
1374 transaction_id id,
1375 const NanTCARequest& msg) {
1376 NanTCARequest msg_internal(msg);
1377 return global_func_table_.wifi_nan_tca_request(
1378 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001379}
1380
1381wifi_error WifiLegacyHal::nanBeaconSdfPayloadRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001382 const std::string& iface_name, transaction_id id,
1383 const NanBeaconSdfPayloadRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001384 NanBeaconSdfPayloadRequest msg_internal(msg);
1385 return global_func_table_.wifi_nan_beacon_sdf_payload_request(
1386 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001387}
1388
1389std::pair<wifi_error, NanVersion> WifiLegacyHal::nanGetVersion() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001390 NanVersion version;
1391 wifi_error status =
1392 global_func_table_.wifi_nan_get_version(global_handle_, &version);
1393 return {status, version};
Roshan Pius23012092016-10-28 11:27:40 -07001394}
1395
Roshan Piusabcf78f2017-10-06 16:30:38 -07001396wifi_error WifiLegacyHal::nanGetCapabilities(const std::string& iface_name,
1397 transaction_id id) {
1398 return global_func_table_.wifi_nan_get_capabilities(
1399 id, getIfaceHandle(iface_name));
Roshan Pius23012092016-10-28 11:27:40 -07001400}
1401
1402wifi_error WifiLegacyHal::nanDataInterfaceCreate(
Roshan Piusacededb2017-10-06 14:59:26 -07001403 const std::string& iface_name, transaction_id id,
1404 const std::string& data_iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001405 return global_func_table_.wifi_nan_data_interface_create(
1406 id, getIfaceHandle(iface_name), makeCharVec(data_iface_name).data());
Roshan Pius23012092016-10-28 11:27:40 -07001407}
1408
1409wifi_error WifiLegacyHal::nanDataInterfaceDelete(
Roshan Piusacededb2017-10-06 14:59:26 -07001410 const std::string& iface_name, transaction_id id,
1411 const std::string& data_iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001412 return global_func_table_.wifi_nan_data_interface_delete(
1413 id, getIfaceHandle(iface_name), makeCharVec(data_iface_name).data());
Roshan Pius23012092016-10-28 11:27:40 -07001414}
1415
1416wifi_error WifiLegacyHal::nanDataRequestInitiator(
Roshan Piusacededb2017-10-06 14:59:26 -07001417 const std::string& iface_name, transaction_id id,
1418 const NanDataPathInitiatorRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001419 NanDataPathInitiatorRequest msg_internal(msg);
1420 return global_func_table_.wifi_nan_data_request_initiator(
1421 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001422}
1423
1424wifi_error WifiLegacyHal::nanDataIndicationResponse(
Roshan Piusacededb2017-10-06 14:59:26 -07001425 const std::string& iface_name, transaction_id id,
1426 const NanDataPathIndicationResponse& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001427 NanDataPathIndicationResponse msg_internal(msg);
1428 return global_func_table_.wifi_nan_data_indication_response(
1429 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001430}
1431
Etan Cohenc9836f92017-06-30 13:55:21 -07001432typedef struct {
1433 u8 num_ndp_instances;
1434 NanDataPathId ndp_instance_id;
1435} NanDataPathEndSingleNdpIdRequest;
1436
Roshan Piusabcf78f2017-10-06 16:30:38 -07001437wifi_error WifiLegacyHal::nanDataEnd(const std::string& iface_name,
1438 transaction_id id,
1439 uint32_t ndpInstanceId) {
1440 NanDataPathEndSingleNdpIdRequest msg;
1441 msg.num_ndp_instances = 1;
1442 msg.ndp_instance_id = ndpInstanceId;
1443 wifi_error status = global_func_table_.wifi_nan_data_end(
1444 id, getIfaceHandle(iface_name), (NanDataPathEndRequest*)&msg);
1445 return status;
Roshan Pius23012092016-10-28 11:27:40 -07001446}
1447
Roshan Piusabcf78f2017-10-06 16:30:38 -07001448wifi_error WifiLegacyHal::setCountryCode(const std::string& iface_name,
1449 std::array<int8_t, 2> code) {
1450 std::string code_str(code.data(), code.data() + code.size());
1451 return global_func_table_.wifi_set_country_code(getIfaceHandle(iface_name),
1452 code_str.c_str());
Roshan Pius32fc12e2017-01-25 17:44:42 -08001453}
1454
Roshan Piusacededb2017-10-06 14:59:26 -07001455wifi_error WifiLegacyHal::retrieveIfaceHandles() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001456 wifi_interface_handle* iface_handles = nullptr;
1457 int num_iface_handles = 0;
1458 wifi_error status = global_func_table_.wifi_get_ifaces(
1459 global_handle_, &num_iface_handles, &iface_handles);
Roshan Piusaabe5752016-09-29 09:03:59 -07001460 if (status != WIFI_SUCCESS) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001461 LOG(ERROR) << "Failed to enumerate interface handles";
1462 return status;
Roshan Piusaabe5752016-09-29 09:03:59 -07001463 }
Sunil Raviddab4bb2020-02-03 22:45:19 -08001464 iface_name_to_handle_.clear();
Roshan Piusabcf78f2017-10-06 16:30:38 -07001465 for (int i = 0; i < num_iface_handles; ++i) {
1466 std::array<char, IFNAMSIZ> iface_name_arr = {};
1467 status = global_func_table_.wifi_get_iface_name(
1468 iface_handles[i], iface_name_arr.data(), iface_name_arr.size());
1469 if (status != WIFI_SUCCESS) {
1470 LOG(WARNING) << "Failed to get interface handle name";
1471 continue;
1472 }
1473 // Assuming the interface name is null terminated since the legacy HAL
1474 // API does not return a size.
1475 std::string iface_name(iface_name_arr.data());
1476 LOG(INFO) << "Adding interface handle for " << iface_name;
1477 iface_name_to_handle_[iface_name] = iface_handles[i];
1478 }
1479 return WIFI_SUCCESS;
Roshan Piusacededb2017-10-06 14:59:26 -07001480}
1481
1482wifi_interface_handle WifiLegacyHal::getIfaceHandle(
1483 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001484 const auto iface_handle_iter = iface_name_to_handle_.find(iface_name);
1485 if (iface_handle_iter == iface_name_to_handle_.end()) {
1486 LOG(ERROR) << "Unknown iface name: " << iface_name;
1487 return nullptr;
1488 }
1489 return iface_handle_iter->second;
Roshan Piusaabe5752016-09-29 09:03:59 -07001490}
1491
1492void WifiLegacyHal::runEventLoop() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001493 LOG(DEBUG) << "Starting legacy HAL event loop";
1494 global_func_table_.wifi_event_loop(global_handle_);
1495 const auto lock = hidl_sync_util::acquireGlobalLock();
1496 if (!awaiting_event_loop_termination_) {
1497 LOG(FATAL)
1498 << "Legacy HAL event loop terminated, but HAL was not stopping";
1499 }
1500 LOG(DEBUG) << "Legacy HAL event loop terminated";
1501 awaiting_event_loop_termination_ = false;
1502 stop_wait_cv_.notify_one();
Roshan Piusaabe5752016-09-29 09:03:59 -07001503}
1504
Roshan Pius76ff3022016-10-28 10:33:34 -07001505std::pair<wifi_error, std::vector<wifi_cached_scan_results>>
Roshan Piusacededb2017-10-06 14:59:26 -07001506WifiLegacyHal::getGscanCachedResults(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001507 std::vector<wifi_cached_scan_results> cached_scan_results;
1508 cached_scan_results.resize(kMaxCachedGscanResults);
1509 int32_t num_results = 0;
1510 wifi_error status = global_func_table_.wifi_get_cached_gscan_results(
1511 getIfaceHandle(iface_name), true /* always flush */,
1512 cached_scan_results.size(), cached_scan_results.data(), &num_results);
1513 CHECK(num_results >= 0 &&
1514 static_cast<uint32_t>(num_results) <= kMaxCachedGscanResults);
1515 cached_scan_results.resize(num_results);
1516 // Check for invalid IE lengths in these cached scan results and correct it.
1517 for (auto& cached_scan_result : cached_scan_results) {
1518 int num_scan_results = cached_scan_result.num_results;
1519 for (int i = 0; i < num_scan_results; i++) {
1520 auto& scan_result = cached_scan_result.results[i];
1521 if (scan_result.ie_length > 0) {
1522 LOG(DEBUG) << "Cached scan result has non-zero IE length "
1523 << scan_result.ie_length;
1524 scan_result.ie_length = 0;
1525 }
1526 }
Roshan Pius76ff3022016-10-28 10:33:34 -07001527 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001528 return {status, std::move(cached_scan_results)};
Roshan Pius76ff3022016-10-28 10:33:34 -07001529}
1530
Sunil Raviddab4bb2020-02-03 22:45:19 -08001531wifi_error WifiLegacyHal::createVirtualInterface(const std::string& ifname,
1532 wifi_interface_type iftype) {
1533 // Create the interface if it doesn't exist. If interface already exist,
1534 // Vendor Hal should return WIFI_SUCCESS.
1535 wifi_error status = global_func_table_.wifi_virtual_interface_create(
1536 global_handle_, ifname.c_str(), iftype);
1537 return handleVirtualInterfaceCreateOrDeleteStatus(ifname, status);
1538}
1539
1540wifi_error WifiLegacyHal::deleteVirtualInterface(const std::string& ifname) {
1541 // Delete the interface if it was created dynamically.
1542 wifi_error status = global_func_table_.wifi_virtual_interface_delete(
1543 global_handle_, ifname.c_str());
1544 return handleVirtualInterfaceCreateOrDeleteStatus(ifname, status);
1545}
1546
1547wifi_error WifiLegacyHal::handleVirtualInterfaceCreateOrDeleteStatus(
1548 const std::string& ifname, wifi_error status) {
1549 if (status == WIFI_SUCCESS) {
1550 // refresh list of handlers now.
1551 status = retrieveIfaceHandles();
1552 } else if (status == WIFI_ERROR_NOT_SUPPORTED) {
1553 // Vendor hal does not implement this API. Such vendor implementations
1554 // are expected to create / delete interface by other means.
1555
1556 // check if interface exists.
1557 if (if_nametoindex(ifname.c_str())) {
1558 status = retrieveIfaceHandles();
1559 }
1560 }
1561 return status;
1562}
1563
Jimmy Chen2dddd792019-12-23 17:50:39 +02001564wifi_error WifiLegacyHal::getSupportedIfaceName(uint32_t iface_type,
1565 std::string& ifname) {
1566 std::array<char, IFNAMSIZ> buffer;
1567
1568 wifi_error res = global_func_table_.wifi_get_supported_iface_name(
1569 global_handle_, (uint32_t)iface_type, buffer.data(), buffer.size());
1570 if (res == WIFI_SUCCESS) ifname = buffer.data();
1571
1572 return res;
1573}
1574
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001575wifi_error WifiLegacyHal::multiStaSetPrimaryConnection(
1576 const std::string& ifname) {
1577 return global_func_table_.wifi_multi_sta_set_primary_connection(
1578 global_handle_, getIfaceHandle(ifname));
1579}
1580
1581wifi_error WifiLegacyHal::multiStaSetUseCase(wifi_multi_sta_use_case use_case) {
1582 return global_func_table_.wifi_multi_sta_set_use_case(global_handle_,
1583 use_case);
1584}
1585
Quang Luong94bcce52020-11-25 17:52:19 -08001586wifi_error WifiLegacyHal::setCoexUnsafeChannels(
1587 std::vector<wifi_coex_unsafe_channel> unsafe_channels,
1588 uint32_t restrictions) {
1589 return global_func_table_.wifi_set_coex_unsafe_channels(
1590 global_handle_, unsafe_channels.size(), unsafe_channels.data(),
1591 restrictions);
1592}
1593
Kai Shi2ca7a112020-12-15 19:51:28 -08001594wifi_error WifiLegacyHal::setVoipMode(const std::string& iface_name,
1595 wifi_voip_mode mode) {
1596 return global_func_table_.wifi_set_voip_mode(getIfaceHandle(iface_name),
1597 mode);
1598}
1599
1600wifi_error WifiLegacyHal::twtRegisterHandler(
1601 const std::string& iface_name, const TwtCallbackHandlers& user_callbacks) {
1602 on_twt_event_setup_response_callback = user_callbacks.on_setup_response;
1603 on_twt_event_teardown_completion_callback =
1604 user_callbacks.on_teardown_completion;
1605 on_twt_event_info_frame_received_callback =
1606 user_callbacks.on_info_frame_received;
1607 on_twt_event_device_notify_callback = user_callbacks.on_device_notify;
1608
1609 return global_func_table_.wifi_twt_register_handler(
1610 getIfaceHandle(iface_name),
1611 {onAsyncTwtEventSetupResponse, onAsyncTwtEventTeardownCompletion,
1612 onAsyncTwtEventInfoFrameReceived, onAsyncTwtEventDeviceNotify});
1613}
1614
1615std::pair<wifi_error, TwtCapabilitySet> WifiLegacyHal::twtGetCapability(
1616 const std::string& iface_name) {
1617 TwtCapabilitySet capSet;
1618 wifi_error status = global_func_table_.wifi_twt_get_capability(
1619 getIfaceHandle(iface_name), &capSet);
1620 return {status, capSet};
1621}
1622
1623wifi_error WifiLegacyHal::twtSetupRequest(const std::string& iface_name,
1624 const TwtSetupRequest& msg) {
1625 TwtSetupRequest msgInternal(msg);
1626 return global_func_table_.wifi_twt_setup_request(getIfaceHandle(iface_name),
1627 &msgInternal);
1628}
1629
1630wifi_error WifiLegacyHal::twtTearDownRequest(const std::string& iface_name,
1631 const TwtTeardownRequest& msg) {
1632 TwtTeardownRequest msgInternal(msg);
1633 return global_func_table_.wifi_twt_teardown_request(
1634 getIfaceHandle(iface_name), &msgInternal);
1635}
1636
1637wifi_error WifiLegacyHal::twtInfoFrameRequest(const std::string& iface_name,
1638 const TwtInfoFrameRequest& msg) {
1639 TwtInfoFrameRequest msgInternal(msg);
1640 return global_func_table_.wifi_twt_info_frame_request(
1641 getIfaceHandle(iface_name), &msgInternal);
1642}
1643
1644std::pair<wifi_error, TwtStats> WifiLegacyHal::twtGetStats(
1645 const std::string& iface_name, uint8_t configId) {
1646 TwtStats stats;
1647 wifi_error status = global_func_table_.wifi_twt_get_stats(
1648 getIfaceHandle(iface_name), configId, &stats);
1649 return {status, stats};
1650}
1651
1652wifi_error WifiLegacyHal::twtClearStats(const std::string& iface_name,
1653 uint8_t configId) {
1654 return global_func_table_.wifi_twt_clear_stats(getIfaceHandle(iface_name),
1655 configId);
1656}
1657
Kai Shi0b6341c2021-01-11 20:22:59 -08001658wifi_error WifiLegacyHal::setDtimConfig(const std::string& iface_name,
1659 uint32_t multiplier) {
1660 return global_func_table_.wifi_set_dtim_config(getIfaceHandle(iface_name),
1661 multiplier);
1662}
1663
Kumar Anand2a630a32021-01-21 14:09:14 -08001664std::pair<wifi_error, std::vector<wifi_usable_channel>>
Kumar Anandaea86e02021-02-10 16:22:31 -08001665WifiLegacyHal::getUsableChannels(uint32_t band_mask, uint32_t iface_mode_mask,
1666 uint32_t filter_mask) {
Kumar Anand2a630a32021-01-21 14:09:14 -08001667 std::vector<wifi_usable_channel> channels;
1668 channels.resize(kMaxWifiUsableChannels);
1669 uint32_t size = 0;
1670 wifi_error status = global_func_table_.wifi_get_usable_channels(
Kumar Anandaea86e02021-02-10 16:22:31 -08001671 global_handle_, band_mask, iface_mode_mask, filter_mask,
1672 channels.size(), &size,
Kumar Anand2a630a32021-01-21 14:09:14 -08001673 reinterpret_cast<wifi_usable_channel*>(channels.data()));
1674 CHECK(size >= 0 && size <= kMaxWifiUsableChannels);
1675 channels.resize(size);
1676 return {status, std::move(channels)};
1677}
1678
chenpaulc6f57032021-03-05 17:06:50 +08001679wifi_error WifiLegacyHal::triggerSubsystemRestart() {
1680 return global_func_table_.wifi_trigger_subsystem_restart();
1681}
1682
Roshan Pius511cc492016-10-28 09:54:26 -07001683void WifiLegacyHal::invalidate() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001684 global_handle_ = nullptr;
1685 iface_name_to_handle_.clear();
1686 on_driver_memory_dump_internal_callback = nullptr;
1687 on_firmware_memory_dump_internal_callback = nullptr;
1688 on_gscan_event_internal_callback = nullptr;
1689 on_gscan_full_result_internal_callback = nullptr;
1690 on_link_layer_stats_result_internal_callback = nullptr;
1691 on_rssi_threshold_breached_internal_callback = nullptr;
1692 on_ring_buffer_data_internal_callback = nullptr;
1693 on_error_alert_internal_callback = nullptr;
Roshan Pius01f08772018-01-22 17:56:06 -08001694 on_radio_mode_change_internal_callback = nullptr;
Ahmed ElArabawy2134bf72020-06-18 15:07:12 -07001695 on_subsystem_restart_internal_callback = nullptr;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001696 on_rtt_results_internal_callback = nullptr;
1697 on_nan_notify_response_user_callback = nullptr;
1698 on_nan_event_publish_terminated_user_callback = nullptr;
1699 on_nan_event_match_user_callback = nullptr;
1700 on_nan_event_match_expired_user_callback = nullptr;
1701 on_nan_event_subscribe_terminated_user_callback = nullptr;
1702 on_nan_event_followup_user_callback = nullptr;
1703 on_nan_event_disc_eng_event_user_callback = nullptr;
1704 on_nan_event_disabled_user_callback = nullptr;
1705 on_nan_event_tca_user_callback = nullptr;
1706 on_nan_event_beacon_sdf_payload_user_callback = nullptr;
1707 on_nan_event_data_path_request_user_callback = nullptr;
1708 on_nan_event_data_path_confirm_user_callback = nullptr;
1709 on_nan_event_data_path_end_user_callback = nullptr;
1710 on_nan_event_transmit_follow_up_user_callback = nullptr;
1711 on_nan_event_range_request_user_callback = nullptr;
1712 on_nan_event_range_report_user_callback = nullptr;
Etan Cohen1bf15f12017-12-12 16:15:16 -08001713 on_nan_event_schedule_update_user_callback = nullptr;
Kai Shi2ca7a112020-12-15 19:51:28 -08001714 on_twt_event_setup_response_callback = nullptr;
1715 on_twt_event_teardown_completion_callback = nullptr;
1716 on_twt_event_info_frame_received_callback = nullptr;
1717 on_twt_event_device_notify_callback = nullptr;
Roshan Pius511cc492016-10-28 09:54:26 -07001718}
Roshan Pius955542e2016-10-28 09:42:44 -07001719
1720} // namespace legacy_hal
Roshan Piusaabe5752016-09-29 09:03:59 -07001721} // namespace implementation
Jimmy Chend460df32019-11-29 17:31:22 +02001722} // namespace V1_5
Roshan Piusaabe5752016-09-29 09:03:59 -07001723} // namespace wifi
1724} // namespace hardware
1725} // namespace android