blob: 2cd7c2ad878c7c8bc16e3ba131502bb663d4aa2e [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>
Roshan Piusaabe5752016-09-29 09:03:59 -070022
Roshan Pius091e1c12017-01-30 16:40:50 -080023#include "hidl_sync_util.h"
Roshan Pius955542e2016-10-28 09:42:44 -070024#include "wifi_legacy_hal.h"
Roshan Piuse73a5062016-12-12 08:53:34 -080025#include "wifi_legacy_hal_stubs.h"
Roshan Pius97334112016-11-18 14:07:54 -080026
Roshan Pius32fc12e2017-01-25 17:44:42 -080027namespace {
Roshan Pius76ff3022016-10-28 10:33:34 -070028// Constants ported over from the legacy HAL calling code
29// (com_android_server_wifi_WifiNative.cpp). This will all be thrown
30// away when this shim layer is replaced by the real vendor
31// implementation.
Roshan Pius511cc492016-10-28 09:54:26 -070032static constexpr uint32_t kMaxVersionStringLength = 256;
Roshan Pius76ff3022016-10-28 10:33:34 -070033static constexpr uint32_t kMaxCachedGscanResults = 64;
34static constexpr uint32_t kMaxGscanFrequenciesForBand = 64;
Roshan Pius7cece412016-10-28 10:38:21 -070035static constexpr uint32_t kLinkLayerStatsDataMpduSizeThreshold = 128;
Roshan Pius8714a3e2016-10-28 10:43:51 -070036static constexpr uint32_t kMaxWakeReasonStatsArraySize = 32;
37static constexpr uint32_t kMaxRingBuffers = 10;
Roshan Pius9bd4e6b2017-09-29 15:04:33 -070038static constexpr uint32_t kMaxStopCompleteWaitMs = 100;
Ahmed ElArabawy7153e812018-06-05 11:09:39 -070039static constexpr char kDriverPropName[] = "wlan.driver.status";
Roshan Pius511cc492016-10-28 09:54:26 -070040
Roshan Pius32fc12e2017-01-25 17:44:42 -080041// Helper function to create a non-const char* for legacy Hal API's.
42std::vector<char> makeCharVec(const std::string& str) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070043 std::vector<char> vec(str.size() + 1);
44 vec.assign(str.begin(), str.end());
45 vec.push_back('\0');
46 return vec;
Roshan Pius32fc12e2017-01-25 17:44:42 -080047}
48} // namespace
49
50namespace android {
51namespace hardware {
52namespace wifi {
Jong Wook Kimda830c92018-07-23 15:29:38 -070053namespace V1_3 {
Roshan Pius32fc12e2017-01-25 17:44:42 -080054namespace implementation {
55namespace legacy_hal {
Roshan Piusaabe5752016-09-29 09:03:59 -070056// Legacy HAL functions accept "C" style function pointers, so use global
57// functions to pass to the legacy HAL function and store the corresponding
58// std::function methods to be invoked.
Roshan Pius155344b2017-08-11 15:47:42 -070059//
60// Callback to be invoked once |stop| is complete
Roshan Piusaabe5752016-09-29 09:03:59 -070061std::function<void(wifi_handle handle)> on_stop_complete_internal_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -080062void onAsyncStopComplete(wifi_handle handle) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070063 const auto lock = hidl_sync_util::acquireGlobalLock();
64 if (on_stop_complete_internal_callback) {
65 on_stop_complete_internal_callback(handle);
66 // Invalidate this callback since we don't want this firing again.
67 on_stop_complete_internal_callback = nullptr;
68 }
Roshan Piusaabe5752016-09-29 09:03:59 -070069}
Roshan Piuscdb77f32016-10-03 14:09:57 -070070
71// Callback to be invoked for driver dump.
72std::function<void(char*, int)> on_driver_memory_dump_internal_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -080073void onSyncDriverMemoryDump(char* buffer, int buffer_size) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070074 if (on_driver_memory_dump_internal_callback) {
75 on_driver_memory_dump_internal_callback(buffer, buffer_size);
76 }
Roshan Piuscdb77f32016-10-03 14:09:57 -070077}
78
79// Callback to be invoked for firmware dump.
80std::function<void(char*, int)> on_firmware_memory_dump_internal_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -080081void onSyncFirmwareMemoryDump(char* buffer, int buffer_size) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070082 if (on_firmware_memory_dump_internal_callback) {
83 on_firmware_memory_dump_internal_callback(buffer, buffer_size);
84 }
Roshan Piuscdb77f32016-10-03 14:09:57 -070085}
Roshan Pius76ff3022016-10-28 10:33:34 -070086
87// Callback to be invoked for Gscan events.
88std::function<void(wifi_request_id, wifi_scan_event)>
89 on_gscan_event_internal_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -080090void onAsyncGscanEvent(wifi_request_id id, wifi_scan_event event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070091 const auto lock = hidl_sync_util::acquireGlobalLock();
92 if (on_gscan_event_internal_callback) {
93 on_gscan_event_internal_callback(id, event);
94 }
Roshan Pius76ff3022016-10-28 10:33:34 -070095}
96
97// Callback to be invoked for Gscan full results.
98std::function<void(wifi_request_id, wifi_scan_result*, uint32_t)>
99 on_gscan_full_result_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700100void onAsyncGscanFullResult(wifi_request_id id, wifi_scan_result* result,
Roshan Pius091e1c12017-01-30 16:40:50 -0800101 uint32_t buckets_scanned) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700102 const auto lock = hidl_sync_util::acquireGlobalLock();
103 if (on_gscan_full_result_internal_callback) {
104 on_gscan_full_result_internal_callback(id, result, buckets_scanned);
105 }
Roshan Pius76ff3022016-10-28 10:33:34 -0700106}
107
Roshan Pius7cece412016-10-28 10:38:21 -0700108// Callback to be invoked for link layer stats results.
109std::function<void((wifi_request_id, wifi_iface_stat*, int, wifi_radio_stat*))>
110 on_link_layer_stats_result_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700111void onSyncLinkLayerStatsResult(wifi_request_id id, wifi_iface_stat* iface_stat,
112 int num_radios, wifi_radio_stat* radio_stat) {
113 if (on_link_layer_stats_result_internal_callback) {
114 on_link_layer_stats_result_internal_callback(id, iface_stat, num_radios,
115 radio_stat);
116 }
Roshan Pius7cece412016-10-28 10:38:21 -0700117}
118
Roshan Piusd4767542016-12-06 10:04:05 -0800119// Callback to be invoked for rssi threshold breach.
120std::function<void((wifi_request_id, uint8_t*, int8_t))>
121 on_rssi_threshold_breached_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700122void onAsyncRssiThresholdBreached(wifi_request_id id, uint8_t* bssid,
Roshan Pius091e1c12017-01-30 16:40:50 -0800123 int8_t rssi) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700124 const auto lock = hidl_sync_util::acquireGlobalLock();
125 if (on_rssi_threshold_breached_internal_callback) {
126 on_rssi_threshold_breached_internal_callback(id, bssid, rssi);
127 }
Roshan Piusd4767542016-12-06 10:04:05 -0800128}
129
Roshan Pius8714a3e2016-10-28 10:43:51 -0700130// Callback to be invoked for ring buffer data indication.
131std::function<void(char*, char*, int, wifi_ring_buffer_status*)>
132 on_ring_buffer_data_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700133void onAsyncRingBufferData(char* ring_name, char* buffer, int buffer_size,
Roshan Pius091e1c12017-01-30 16:40:50 -0800134 wifi_ring_buffer_status* status) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700135 const auto lock = hidl_sync_util::acquireGlobalLock();
136 if (on_ring_buffer_data_internal_callback) {
137 on_ring_buffer_data_internal_callback(ring_name, buffer, buffer_size,
138 status);
139 }
Roshan Pius8714a3e2016-10-28 10:43:51 -0700140}
141
Roshan Pius203cb032016-12-14 17:41:20 -0800142// Callback to be invoked for error alert indication.
143std::function<void(wifi_request_id, char*, int, int)>
144 on_error_alert_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700145void onAsyncErrorAlert(wifi_request_id id, char* buffer, int buffer_size,
Roshan Pius091e1c12017-01-30 16:40:50 -0800146 int err_code) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700147 const auto lock = hidl_sync_util::acquireGlobalLock();
148 if (on_error_alert_internal_callback) {
149 on_error_alert_internal_callback(id, buffer, buffer_size, err_code);
150 }
Roshan Pius203cb032016-12-14 17:41:20 -0800151}
152
Roshan Pius01f08772018-01-22 17:56:06 -0800153// Callback to be invoked for radio mode change indication.
154std::function<void(wifi_request_id, uint32_t, wifi_mac_info*)>
155 on_radio_mode_change_internal_callback;
156void onAsyncRadioModeChange(wifi_request_id id, uint32_t num_macs,
157 wifi_mac_info* mac_infos) {
158 const auto lock = hidl_sync_util::acquireGlobalLock();
159 if (on_radio_mode_change_internal_callback) {
160 on_radio_mode_change_internal_callback(id, num_macs, mac_infos);
161 }
162}
163
Roshan Piusd8e915a2016-10-28 11:23:11 -0700164// Callback to be invoked for rtt results results.
Roshan Piusabcf78f2017-10-06 16:30:38 -0700165std::function<void(wifi_request_id, unsigned num_results,
166 wifi_rtt_result* rtt_results[])>
Roshan Piusd8e915a2016-10-28 11:23:11 -0700167 on_rtt_results_internal_callback;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700168void onAsyncRttResults(wifi_request_id id, unsigned num_results,
Roshan Pius091e1c12017-01-30 16:40:50 -0800169 wifi_rtt_result* rtt_results[]) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700170 const auto lock = hidl_sync_util::acquireGlobalLock();
171 if (on_rtt_results_internal_callback) {
172 on_rtt_results_internal_callback(id, num_results, rtt_results);
173 on_rtt_results_internal_callback = nullptr;
174 }
Roshan Piusd8e915a2016-10-28 11:23:11 -0700175}
176
Roshan Pius23012092016-10-28 11:27:40 -0700177// Callbacks for the various NAN operations.
178// NOTE: These have very little conversions to perform before invoking the user
179// callbacks.
180// So, handle all of them here directly to avoid adding an unnecessary layer.
181std::function<void(transaction_id, const NanResponseMsg&)>
182 on_nan_notify_response_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800183void onAysncNanNotifyResponse(transaction_id id, NanResponseMsg* msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700184 const auto lock = hidl_sync_util::acquireGlobalLock();
185 if (on_nan_notify_response_user_callback && msg) {
186 on_nan_notify_response_user_callback(id, *msg);
187 }
Roshan Pius23012092016-10-28 11:27:40 -0700188}
189
Etan Cohen20925b02017-04-04 13:00:14 -0700190std::function<void(const NanPublishRepliedInd&)>
191 on_nan_event_publish_replied_user_callback;
192void onAysncNanEventPublishReplied(NanPublishRepliedInd* /* event */) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700193 LOG(ERROR) << "onAysncNanEventPublishReplied triggered";
Etan Cohen20925b02017-04-04 13:00:14 -0700194}
195
Roshan Pius23012092016-10-28 11:27:40 -0700196std::function<void(const NanPublishTerminatedInd&)>
197 on_nan_event_publish_terminated_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800198void onAysncNanEventPublishTerminated(NanPublishTerminatedInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700199 const auto lock = hidl_sync_util::acquireGlobalLock();
200 if (on_nan_event_publish_terminated_user_callback && event) {
201 on_nan_event_publish_terminated_user_callback(*event);
202 }
Roshan Pius23012092016-10-28 11:27:40 -0700203}
204
205std::function<void(const NanMatchInd&)> on_nan_event_match_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800206void onAysncNanEventMatch(NanMatchInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700207 const auto lock = hidl_sync_util::acquireGlobalLock();
208 if (on_nan_event_match_user_callback && event) {
209 on_nan_event_match_user_callback(*event);
210 }
Roshan Pius23012092016-10-28 11:27:40 -0700211}
212
213std::function<void(const NanMatchExpiredInd&)>
214 on_nan_event_match_expired_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800215void onAysncNanEventMatchExpired(NanMatchExpiredInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700216 const auto lock = hidl_sync_util::acquireGlobalLock();
217 if (on_nan_event_match_expired_user_callback && event) {
218 on_nan_event_match_expired_user_callback(*event);
219 }
Roshan Pius23012092016-10-28 11:27:40 -0700220}
221
222std::function<void(const NanSubscribeTerminatedInd&)>
223 on_nan_event_subscribe_terminated_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800224void onAysncNanEventSubscribeTerminated(NanSubscribeTerminatedInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700225 const auto lock = hidl_sync_util::acquireGlobalLock();
226 if (on_nan_event_subscribe_terminated_user_callback && event) {
227 on_nan_event_subscribe_terminated_user_callback(*event);
228 }
Roshan Pius23012092016-10-28 11:27:40 -0700229}
230
231std::function<void(const NanFollowupInd&)> on_nan_event_followup_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800232void onAysncNanEventFollowup(NanFollowupInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700233 const auto lock = hidl_sync_util::acquireGlobalLock();
234 if (on_nan_event_followup_user_callback && event) {
235 on_nan_event_followup_user_callback(*event);
236 }
Roshan Pius23012092016-10-28 11:27:40 -0700237}
238
239std::function<void(const NanDiscEngEventInd&)>
240 on_nan_event_disc_eng_event_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800241void onAysncNanEventDiscEngEvent(NanDiscEngEventInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700242 const auto lock = hidl_sync_util::acquireGlobalLock();
243 if (on_nan_event_disc_eng_event_user_callback && event) {
244 on_nan_event_disc_eng_event_user_callback(*event);
245 }
Roshan Pius23012092016-10-28 11:27:40 -0700246}
247
248std::function<void(const NanDisabledInd&)> on_nan_event_disabled_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800249void onAysncNanEventDisabled(NanDisabledInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700250 const auto lock = hidl_sync_util::acquireGlobalLock();
251 if (on_nan_event_disabled_user_callback && event) {
252 on_nan_event_disabled_user_callback(*event);
253 }
Roshan Pius23012092016-10-28 11:27:40 -0700254}
255
256std::function<void(const NanTCAInd&)> on_nan_event_tca_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800257void onAysncNanEventTca(NanTCAInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700258 const auto lock = hidl_sync_util::acquireGlobalLock();
259 if (on_nan_event_tca_user_callback && event) {
260 on_nan_event_tca_user_callback(*event);
261 }
Roshan Pius23012092016-10-28 11:27:40 -0700262}
263
264std::function<void(const NanBeaconSdfPayloadInd&)>
265 on_nan_event_beacon_sdf_payload_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800266void onAysncNanEventBeaconSdfPayload(NanBeaconSdfPayloadInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700267 const auto lock = hidl_sync_util::acquireGlobalLock();
268 if (on_nan_event_beacon_sdf_payload_user_callback && event) {
269 on_nan_event_beacon_sdf_payload_user_callback(*event);
270 }
Roshan Pius23012092016-10-28 11:27:40 -0700271}
272
273std::function<void(const NanDataPathRequestInd&)>
274 on_nan_event_data_path_request_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800275void onAysncNanEventDataPathRequest(NanDataPathRequestInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700276 const auto lock = hidl_sync_util::acquireGlobalLock();
277 if (on_nan_event_data_path_request_user_callback && event) {
278 on_nan_event_data_path_request_user_callback(*event);
279 }
Roshan Pius23012092016-10-28 11:27:40 -0700280}
281std::function<void(const NanDataPathConfirmInd&)>
282 on_nan_event_data_path_confirm_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800283void onAysncNanEventDataPathConfirm(NanDataPathConfirmInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700284 const auto lock = hidl_sync_util::acquireGlobalLock();
285 if (on_nan_event_data_path_confirm_user_callback && event) {
286 on_nan_event_data_path_confirm_user_callback(*event);
287 }
Roshan Pius23012092016-10-28 11:27:40 -0700288}
289
290std::function<void(const NanDataPathEndInd&)>
291 on_nan_event_data_path_end_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800292void onAysncNanEventDataPathEnd(NanDataPathEndInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700293 const auto lock = hidl_sync_util::acquireGlobalLock();
294 if (on_nan_event_data_path_end_user_callback && event) {
295 on_nan_event_data_path_end_user_callback(*event);
296 }
Roshan Pius23012092016-10-28 11:27:40 -0700297}
298
299std::function<void(const NanTransmitFollowupInd&)>
300 on_nan_event_transmit_follow_up_user_callback;
Roshan Pius091e1c12017-01-30 16:40:50 -0800301void onAysncNanEventTransmitFollowUp(NanTransmitFollowupInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700302 const auto lock = hidl_sync_util::acquireGlobalLock();
303 if (on_nan_event_transmit_follow_up_user_callback && event) {
304 on_nan_event_transmit_follow_up_user_callback(*event);
305 }
Roshan Pius23012092016-10-28 11:27:40 -0700306}
Etan Cohenc190f932017-02-17 13:06:55 -0800307
308std::function<void(const NanRangeRequestInd&)>
309 on_nan_event_range_request_user_callback;
310void onAysncNanEventRangeRequest(NanRangeRequestInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700311 const auto lock = hidl_sync_util::acquireGlobalLock();
312 if (on_nan_event_range_request_user_callback && event) {
313 on_nan_event_range_request_user_callback(*event);
314 }
Etan Cohenc190f932017-02-17 13:06:55 -0800315}
316
317std::function<void(const NanRangeReportInd&)>
318 on_nan_event_range_report_user_callback;
319void onAysncNanEventRangeReport(NanRangeReportInd* event) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700320 const auto lock = hidl_sync_util::acquireGlobalLock();
321 if (on_nan_event_range_report_user_callback && event) {
322 on_nan_event_range_report_user_callback(*event);
323 }
Etan Cohenc190f932017-02-17 13:06:55 -0800324}
Etan Cohen1bf15f12017-12-12 16:15:16 -0800325
326std::function<void(const NanDataPathScheduleUpdateInd&)>
327 on_nan_event_schedule_update_user_callback;
328void onAsyncNanEventScheduleUpdate(NanDataPathScheduleUpdateInd* event) {
329 const auto lock = hidl_sync_util::acquireGlobalLock();
330 if (on_nan_event_schedule_update_user_callback && event) {
331 on_nan_event_schedule_update_user_callback(*event);
332 }
333}
Roshan Pius955542e2016-10-28 09:42:44 -0700334// End of the free-standing "C" style callbacks.
Roshan Piusaabe5752016-09-29 09:03:59 -0700335
Roshan Piusaabe5752016-09-29 09:03:59 -0700336WifiLegacyHal::WifiLegacyHal()
337 : global_handle_(nullptr),
Roshan Pius11f93032016-12-09 10:26:17 -0800338 awaiting_event_loop_termination_(false),
339 is_started_(false) {}
Roshan Piusaabe5752016-09-29 09:03:59 -0700340
Roshan Pius97334112016-11-18 14:07:54 -0800341wifi_error WifiLegacyHal::initialize() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700342 LOG(DEBUG) << "Initialize legacy HAL";
343 // TODO: Add back the HAL Tool if we need to. All we need from the HAL tool
344 // for now is this function call which we can directly call.
345 if (!initHalFuncTableWithStubs(&global_func_table_)) {
346 LOG(ERROR)
347 << "Failed to initialize legacy hal function table with stubs";
348 return WIFI_ERROR_UNKNOWN;
349 }
350 wifi_error status = init_wifi_vendor_hal_func_table(&global_func_table_);
351 if (status != WIFI_SUCCESS) {
352 LOG(ERROR) << "Failed to initialize legacy hal function table";
353 }
354 return status;
Roshan Pius97334112016-11-18 14:07:54 -0800355}
356
357wifi_error WifiLegacyHal::start() {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700358 // Ensure that we're starting in a good state.
359 CHECK(global_func_table_.wifi_initialize && !global_handle_ &&
360 iface_name_to_handle_.empty() && !awaiting_event_loop_termination_);
361 if (is_started_) {
362 LOG(DEBUG) << "Legacy HAL already started";
363 return WIFI_SUCCESS;
364 }
Ahmed ElArabawyc1018152018-03-02 14:35:04 -0800365 LOG(DEBUG) << "Waiting for the driver ready";
366 wifi_error status = global_func_table_.wifi_wait_for_driver_ready();
367 if (status == WIFI_ERROR_TIMED_OUT) {
368 LOG(ERROR) << "Timed out awaiting driver ready";
369 return status;
370 }
Ahmed ElArabawy7153e812018-06-05 11:09:39 -0700371 property_set(kDriverPropName, "ok");
372
Roshan Piusabcf78f2017-10-06 16:30:38 -0700373 LOG(DEBUG) << "Starting legacy HAL";
374 if (!iface_tool_.SetWifiUpState(true)) {
375 LOG(ERROR) << "Failed to set WiFi interface up";
376 return WIFI_ERROR_UNKNOWN;
377 }
Ahmed ElArabawyc1018152018-03-02 14:35:04 -0800378 status = global_func_table_.wifi_initialize(&global_handle_);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700379 if (status != WIFI_SUCCESS || !global_handle_) {
380 LOG(ERROR) << "Failed to retrieve global handle";
381 return status;
382 }
383 std::thread(&WifiLegacyHal::runEventLoop, this).detach();
384 status = retrieveIfaceHandles();
385 if (status != WIFI_SUCCESS || iface_name_to_handle_.empty()) {
386 LOG(ERROR) << "Failed to retrieve wlan interface handle";
387 return status;
388 }
389 LOG(DEBUG) << "Legacy HAL start complete";
390 is_started_ = true;
Roshan Pius11f93032016-12-09 10:26:17 -0800391 return WIFI_SUCCESS;
Roshan Piusaabe5752016-09-29 09:03:59 -0700392}
393
394wifi_error WifiLegacyHal::stop(
Roshan Pius155344b2017-08-11 15:47:42 -0700395 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock,
Roshan Piusaabe5752016-09-29 09:03:59 -0700396 const std::function<void()>& on_stop_complete_user_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700397 if (!is_started_) {
398 LOG(DEBUG) << "Legacy HAL already stopped";
399 on_stop_complete_user_callback();
400 return WIFI_SUCCESS;
401 }
402 LOG(DEBUG) << "Stopping legacy HAL";
403 on_stop_complete_internal_callback = [on_stop_complete_user_callback,
404 this](wifi_handle handle) {
405 CHECK_EQ(global_handle_, handle) << "Handle mismatch";
406 LOG(INFO) << "Legacy HAL stop complete callback received";
407 // Invalidate all the internal pointers now that the HAL is
408 // stopped.
409 invalidate();
410 iface_tool_.SetWifiUpState(false);
411 on_stop_complete_user_callback();
412 is_started_ = false;
413 };
414 awaiting_event_loop_termination_ = true;
415 global_func_table_.wifi_cleanup(global_handle_, onAsyncStopComplete);
416 const auto status = stop_wait_cv_.wait_for(
417 *lock, std::chrono::milliseconds(kMaxStopCompleteWaitMs),
418 [this] { return !awaiting_event_loop_termination_; });
419 if (!status) {
420 LOG(ERROR) << "Legacy HAL stop failed or timed out";
421 return WIFI_ERROR_UNKNOWN;
422 }
423 LOG(DEBUG) << "Legacy HAL stop complete";
Roshan Pius11f93032016-12-09 10:26:17 -0800424 return WIFI_SUCCESS;
Roshan Piusaabe5752016-09-29 09:03:59 -0700425}
426
Roshan Piusacededb2017-10-06 14:59:26 -0700427std::pair<wifi_error, std::string> WifiLegacyHal::getDriverVersion(
428 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700429 std::array<char, kMaxVersionStringLength> buffer;
430 buffer.fill(0);
431 wifi_error status = global_func_table_.wifi_get_driver_version(
432 getIfaceHandle(iface_name), buffer.data(), buffer.size());
433 return {status, buffer.data()};
Roshan Pius4b26c832016-10-03 12:49:58 -0700434}
435
Roshan Piusacededb2017-10-06 14:59:26 -0700436std::pair<wifi_error, std::string> WifiLegacyHal::getFirmwareVersion(
437 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700438 std::array<char, kMaxVersionStringLength> buffer;
439 buffer.fill(0);
440 wifi_error status = global_func_table_.wifi_get_firmware_version(
441 getIfaceHandle(iface_name), buffer.data(), buffer.size());
442 return {status, buffer.data()};
Roshan Pius4b26c832016-10-03 12:49:58 -0700443}
444
Roshan Pius3c868522016-10-27 12:43:49 -0700445std::pair<wifi_error, std::vector<uint8_t>>
Roshan Piusabcf78f2017-10-06 16:30:38 -0700446WifiLegacyHal::requestDriverMemoryDump(const std::string& iface_name) {
447 std::vector<uint8_t> driver_dump;
448 on_driver_memory_dump_internal_callback = [&driver_dump](char* buffer,
449 int buffer_size) {
450 driver_dump.insert(driver_dump.end(),
451 reinterpret_cast<uint8_t*>(buffer),
452 reinterpret_cast<uint8_t*>(buffer) + buffer_size);
453 };
454 wifi_error status = global_func_table_.wifi_get_driver_memory_dump(
455 getIfaceHandle(iface_name), {onSyncDriverMemoryDump});
456 on_driver_memory_dump_internal_callback = nullptr;
457 return {status, std::move(driver_dump)};
Roshan Piuscdb77f32016-10-03 14:09:57 -0700458}
459
Roshan Pius3c868522016-10-27 12:43:49 -0700460std::pair<wifi_error, std::vector<uint8_t>>
Roshan Piusacededb2017-10-06 14:59:26 -0700461WifiLegacyHal::requestFirmwareMemoryDump(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700462 std::vector<uint8_t> firmware_dump;
463 on_firmware_memory_dump_internal_callback =
464 [&firmware_dump](char* buffer, int buffer_size) {
465 firmware_dump.insert(
466 firmware_dump.end(), reinterpret_cast<uint8_t*>(buffer),
467 reinterpret_cast<uint8_t*>(buffer) + buffer_size);
468 };
469 wifi_error status = global_func_table_.wifi_get_firmware_memory_dump(
470 getIfaceHandle(iface_name), {onSyncFirmwareMemoryDump});
471 on_firmware_memory_dump_internal_callback = nullptr;
472 return {status, std::move(firmware_dump)};
Roshan Pius0a47c182016-10-28 10:23:00 -0700473}
474
Roshan Piusacededb2017-10-06 14:59:26 -0700475std::pair<wifi_error, uint32_t> WifiLegacyHal::getSupportedFeatureSet(
476 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700477 feature_set set;
478 static_assert(sizeof(set) == sizeof(uint32_t),
Roshan Pius200a17d2017-11-01 13:03:35 -0700479 "Some feature_flags can not be represented in output");
Roshan Piusabcf78f2017-10-06 16:30:38 -0700480 wifi_error status = global_func_table_.wifi_get_supported_feature_set(
481 getIfaceHandle(iface_name), &set);
482 return {status, static_cast<uint32_t>(set)};
Roshan Pius0a47c182016-10-28 10:23:00 -0700483}
484
485std::pair<wifi_error, PacketFilterCapabilities>
Roshan Piusacededb2017-10-06 14:59:26 -0700486WifiLegacyHal::getPacketFilterCapabilities(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700487 PacketFilterCapabilities caps;
488 wifi_error status = global_func_table_.wifi_get_packet_filter_capabilities(
489 getIfaceHandle(iface_name), &caps.version, &caps.max_len);
490 return {status, caps};
Roshan Pius0a47c182016-10-28 10:23:00 -0700491}
492
Roshan Piusabcf78f2017-10-06 16:30:38 -0700493wifi_error WifiLegacyHal::setPacketFilter(const std::string& iface_name,
494 const std::vector<uint8_t>& program) {
495 return global_func_table_.wifi_set_packet_filter(
496 getIfaceHandle(iface_name), program.data(), program.size());
Roshan Piuscdb77f32016-10-03 14:09:57 -0700497}
498
Bernie Innocenti7e6f71a2018-03-07 00:17:50 +0900499std::pair<wifi_error, std::vector<uint8_t>>
500WifiLegacyHal::readApfPacketFilterData(const std::string& iface_name) {
Bernie Innocenti7e6f71a2018-03-07 00:17:50 +0900501 PacketFilterCapabilities caps;
502 wifi_error status = global_func_table_.wifi_get_packet_filter_capabilities(
503 getIfaceHandle(iface_name), &caps.version, &caps.max_len);
504 if (status != WIFI_SUCCESS) {
505 return {status, {}};
506 }
507
508 // Size the buffer to read the entire program & work memory.
509 std::vector<uint8_t> buffer(caps.max_len);
510
511 status = global_func_table_.wifi_read_packet_filter(
512 getIfaceHandle(iface_name), /*src_offset=*/0, buffer.data(),
513 buffer.size());
514 return {status, move(buffer)};
515}
516
Roshan Pius76ff3022016-10-28 10:33:34 -0700517std::pair<wifi_error, wifi_gscan_capabilities>
Roshan Piusacededb2017-10-06 14:59:26 -0700518WifiLegacyHal::getGscanCapabilities(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700519 wifi_gscan_capabilities caps;
520 wifi_error status = global_func_table_.wifi_get_gscan_capabilities(
521 getIfaceHandle(iface_name), &caps);
522 return {status, caps};
Roshan Pius76ff3022016-10-28 10:33:34 -0700523}
524
525wifi_error WifiLegacyHal::startGscan(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700526 const std::string& iface_name, wifi_request_id id,
Roshan Pius76ff3022016-10-28 10:33:34 -0700527 const wifi_scan_cmd_params& params,
528 const std::function<void(wifi_request_id)>& on_failure_user_callback,
529 const on_gscan_results_callback& on_results_user_callback,
530 const on_gscan_full_result_callback& on_full_result_user_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700531 // If there is already an ongoing background scan, reject new scan requests.
532 if (on_gscan_event_internal_callback ||
533 on_gscan_full_result_internal_callback) {
534 return WIFI_ERROR_NOT_AVAILABLE;
Roshan Pius76ff3022016-10-28 10:33:34 -0700535 }
Roshan Pius76ff3022016-10-28 10:33:34 -0700536
Roshan Piusabcf78f2017-10-06 16:30:38 -0700537 // This callback will be used to either trigger |on_results_user_callback|
538 // or |on_failure_user_callback|.
539 on_gscan_event_internal_callback =
540 [iface_name, on_failure_user_callback, on_results_user_callback, this](
541 wifi_request_id id, wifi_scan_event event) {
542 switch (event) {
543 case WIFI_SCAN_RESULTS_AVAILABLE:
544 case WIFI_SCAN_THRESHOLD_NUM_SCANS:
545 case WIFI_SCAN_THRESHOLD_PERCENT: {
546 wifi_error status;
547 std::vector<wifi_cached_scan_results> cached_scan_results;
548 std::tie(status, cached_scan_results) =
549 getGscanCachedResults(iface_name);
550 if (status == WIFI_SUCCESS) {
551 on_results_user_callback(id, cached_scan_results);
552 return;
553 }
554 }
555 // Fall through if failed. Failure to retrieve cached scan
556 // results should trigger a background scan failure.
557 case WIFI_SCAN_FAILED:
558 on_failure_user_callback(id);
559 on_gscan_event_internal_callback = nullptr;
560 on_gscan_full_result_internal_callback = nullptr;
561 return;
562 }
563 LOG(FATAL) << "Unexpected gscan event received: " << event;
564 };
565
566 on_gscan_full_result_internal_callback = [on_full_result_user_callback](
567 wifi_request_id id,
568 wifi_scan_result* result,
569 uint32_t buckets_scanned) {
570 if (result) {
571 on_full_result_user_callback(id, result, buckets_scanned);
572 }
573 };
574
575 wifi_scan_result_handler handler = {onAsyncGscanFullResult,
576 onAsyncGscanEvent};
577 wifi_error status = global_func_table_.wifi_start_gscan(
578 id, getIfaceHandle(iface_name), params, handler);
579 if (status != WIFI_SUCCESS) {
580 on_gscan_event_internal_callback = nullptr;
581 on_gscan_full_result_internal_callback = nullptr;
582 }
583 return status;
Roshan Pius76ff3022016-10-28 10:33:34 -0700584}
585
Roshan Piusabcf78f2017-10-06 16:30:38 -0700586wifi_error WifiLegacyHal::stopGscan(const std::string& iface_name,
587 wifi_request_id id) {
588 // If there is no an ongoing background scan, reject stop requests.
589 // TODO(b/32337212): This needs to be handled by the HIDL object because we
590 // need to return the NOT_STARTED error code.
591 if (!on_gscan_event_internal_callback &&
592 !on_gscan_full_result_internal_callback) {
593 return WIFI_ERROR_NOT_AVAILABLE;
594 }
595 wifi_error status =
596 global_func_table_.wifi_stop_gscan(id, getIfaceHandle(iface_name));
597 // If the request Id is wrong, don't stop the ongoing background scan. Any
598 // other error should be treated as the end of background scan.
599 if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
600 on_gscan_event_internal_callback = nullptr;
601 on_gscan_full_result_internal_callback = nullptr;
602 }
603 return status;
Roshan Pius76ff3022016-10-28 10:33:34 -0700604}
605
606std::pair<wifi_error, std::vector<uint32_t>>
Roshan Piusabcf78f2017-10-06 16:30:38 -0700607WifiLegacyHal::getValidFrequenciesForBand(const std::string& iface_name,
608 wifi_band band) {
609 static_assert(sizeof(uint32_t) >= sizeof(wifi_channel),
610 "Wifi Channel cannot be represented in output");
611 std::vector<uint32_t> freqs;
612 freqs.resize(kMaxGscanFrequenciesForBand);
613 int32_t num_freqs = 0;
614 wifi_error status = global_func_table_.wifi_get_valid_channels(
615 getIfaceHandle(iface_name), band, freqs.size(),
616 reinterpret_cast<wifi_channel*>(freqs.data()), &num_freqs);
617 CHECK(num_freqs >= 0 &&
618 static_cast<uint32_t>(num_freqs) <= kMaxGscanFrequenciesForBand);
619 freqs.resize(num_freqs);
620 return {status, std::move(freqs)};
Roshan Pius76ff3022016-10-28 10:33:34 -0700621}
622
Roshan Piusabcf78f2017-10-06 16:30:38 -0700623wifi_error WifiLegacyHal::setDfsFlag(const std::string& iface_name,
624 bool dfs_on) {
625 return global_func_table_.wifi_set_nodfs_flag(getIfaceHandle(iface_name),
626 dfs_on ? 0 : 1);
Roshan Pius08d1df42017-04-19 23:11:07 -0700627}
628
Roshan Piusabcf78f2017-10-06 16:30:38 -0700629wifi_error WifiLegacyHal::enableLinkLayerStats(const std::string& iface_name,
630 bool debug) {
631 wifi_link_layer_params params;
632 params.mpdu_size_threshold = kLinkLayerStatsDataMpduSizeThreshold;
633 params.aggressive_statistics_gathering = debug;
634 return global_func_table_.wifi_set_link_stats(getIfaceHandle(iface_name),
635 params);
Roshan Pius7cece412016-10-28 10:38:21 -0700636}
637
Roshan Piusacededb2017-10-06 14:59:26 -0700638wifi_error WifiLegacyHal::disableLinkLayerStats(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700639 // TODO: Do we care about these responses?
640 uint32_t clear_mask_rsp;
641 uint8_t stop_rsp;
642 return global_func_table_.wifi_clear_link_stats(
643 getIfaceHandle(iface_name), 0xFFFFFFFF, &clear_mask_rsp, 1, &stop_rsp);
Roshan Pius7cece412016-10-28 10:38:21 -0700644}
645
Roshan Piusacededb2017-10-06 14:59:26 -0700646std::pair<wifi_error, LinkLayerStats> WifiLegacyHal::getLinkLayerStats(
647 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700648 LinkLayerStats link_stats{};
649 LinkLayerStats* link_stats_ptr = &link_stats;
Roshan Pius7cece412016-10-28 10:38:21 -0700650
Roshan Piusabcf78f2017-10-06 16:30:38 -0700651 on_link_layer_stats_result_internal_callback =
652 [&link_stats_ptr](wifi_request_id /* id */,
653 wifi_iface_stat* iface_stats_ptr, int num_radios,
654 wifi_radio_stat* radio_stats_ptr) {
655 if (iface_stats_ptr != nullptr) {
656 link_stats_ptr->iface = *iface_stats_ptr;
657 link_stats_ptr->iface.num_peers = 0;
658 } else {
659 LOG(ERROR) << "Invalid iface stats in link layer stats";
660 }
661 if (num_radios <= 0 || radio_stats_ptr == nullptr) {
662 LOG(ERROR) << "Invalid radio stats in link layer stats";
663 return;
664 }
665 for (int i = 0; i < num_radios; i++) {
666 LinkLayerRadioStats radio;
667 radio.stats = radio_stats_ptr[i];
668 // Copy over the tx level array to the separate vector.
669 if (radio_stats_ptr[i].num_tx_levels > 0 &&
670 radio_stats_ptr[i].tx_time_per_levels != nullptr) {
671 radio.tx_time_per_levels.assign(
672 radio_stats_ptr[i].tx_time_per_levels,
673 radio_stats_ptr[i].tx_time_per_levels +
674 radio_stats_ptr[i].num_tx_levels);
675 }
676 radio.stats.num_tx_levels = 0;
677 radio.stats.tx_time_per_levels = nullptr;
678 link_stats_ptr->radios.push_back(radio);
679 }
680 };
Roshan Pius7cece412016-10-28 10:38:21 -0700681
Roshan Piusabcf78f2017-10-06 16:30:38 -0700682 wifi_error status = global_func_table_.wifi_get_link_stats(
683 0, getIfaceHandle(iface_name), {onSyncLinkLayerStatsResult});
684 on_link_layer_stats_result_internal_callback = nullptr;
685 return {status, link_stats};
Roshan Pius7cece412016-10-28 10:38:21 -0700686}
687
Roshan Piusd4767542016-12-06 10:04:05 -0800688wifi_error WifiLegacyHal::startRssiMonitoring(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700689 const std::string& iface_name, wifi_request_id id, int8_t max_rssi,
Roshan Piusd4767542016-12-06 10:04:05 -0800690 int8_t min_rssi,
691 const on_rssi_threshold_breached_callback&
692 on_threshold_breached_user_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700693 if (on_rssi_threshold_breached_internal_callback) {
694 return WIFI_ERROR_NOT_AVAILABLE;
695 }
696 on_rssi_threshold_breached_internal_callback =
697 [on_threshold_breached_user_callback](wifi_request_id id,
698 uint8_t* bssid_ptr, int8_t rssi) {
699 if (!bssid_ptr) {
700 return;
701 }
702 std::array<uint8_t, 6> bssid_arr;
703 // |bssid_ptr| pointer is assumed to have 6 bytes for the mac
704 // address.
705 std::copy(bssid_ptr, bssid_ptr + 6, std::begin(bssid_arr));
706 on_threshold_breached_user_callback(id, bssid_arr, rssi);
707 };
708 wifi_error status = global_func_table_.wifi_start_rssi_monitoring(
709 id, getIfaceHandle(iface_name), max_rssi, min_rssi,
710 {onAsyncRssiThresholdBreached});
711 if (status != WIFI_SUCCESS) {
712 on_rssi_threshold_breached_internal_callback = nullptr;
713 }
714 return status;
Roshan Piusd4767542016-12-06 10:04:05 -0800715}
716
Roshan Piusabcf78f2017-10-06 16:30:38 -0700717wifi_error WifiLegacyHal::stopRssiMonitoring(const std::string& iface_name,
718 wifi_request_id id) {
719 if (!on_rssi_threshold_breached_internal_callback) {
720 return WIFI_ERROR_NOT_AVAILABLE;
721 }
722 wifi_error status = global_func_table_.wifi_stop_rssi_monitoring(
723 id, getIfaceHandle(iface_name));
724 // If the request Id is wrong, don't stop the ongoing rssi monitoring. Any
725 // other error should be treated as the end of background scan.
726 if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
727 on_rssi_threshold_breached_internal_callback = nullptr;
728 }
729 return status;
Roshan Piusd4767542016-12-06 10:04:05 -0800730}
731
Roshan Pius26801cb2016-12-13 14:25:45 -0800732std::pair<wifi_error, wifi_roaming_capabilities>
Roshan Piusacededb2017-10-06 14:59:26 -0700733WifiLegacyHal::getRoamingCapabilities(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700734 wifi_roaming_capabilities caps;
735 wifi_error status = global_func_table_.wifi_get_roaming_capabilities(
736 getIfaceHandle(iface_name), &caps);
737 return {status, caps};
Roshan Pius26801cb2016-12-13 14:25:45 -0800738}
739
Roshan Piusabcf78f2017-10-06 16:30:38 -0700740wifi_error WifiLegacyHal::configureRoaming(const std::string& iface_name,
741 const wifi_roaming_config& config) {
742 wifi_roaming_config config_internal = config;
743 return global_func_table_.wifi_configure_roaming(getIfaceHandle(iface_name),
744 &config_internal);
Roshan Piusaf727c02017-01-11 15:37:25 -0800745}
746
Roshan Piusabcf78f2017-10-06 16:30:38 -0700747wifi_error WifiLegacyHal::enableFirmwareRoaming(const std::string& iface_name,
748 fw_roaming_state_t state) {
749 return global_func_table_.wifi_enable_firmware_roaming(
750 getIfaceHandle(iface_name), state);
Roshan Pius26801cb2016-12-13 14:25:45 -0800751}
752
Roshan Piusabcf78f2017-10-06 16:30:38 -0700753wifi_error WifiLegacyHal::configureNdOffload(const std::string& iface_name,
754 bool enable) {
755 return global_func_table_.wifi_configure_nd_offload(
756 getIfaceHandle(iface_name), enable);
Roshan Pius26801cb2016-12-13 14:25:45 -0800757}
758
Roshan Pius9a9869a2017-01-11 16:42:16 -0800759wifi_error WifiLegacyHal::startSendingOffloadedPacket(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700760 const std::string& iface_name, uint32_t cmd_id,
Roshan Pius9a9869a2017-01-11 16:42:16 -0800761 const std::vector<uint8_t>& ip_packet_data,
762 const std::array<uint8_t, 6>& src_address,
Roshan Piusabcf78f2017-10-06 16:30:38 -0700763 const std::array<uint8_t, 6>& dst_address, uint32_t period_in_ms) {
764 std::vector<uint8_t> ip_packet_data_internal(ip_packet_data);
765 std::vector<uint8_t> src_address_internal(
766 src_address.data(), src_address.data() + src_address.size());
767 std::vector<uint8_t> dst_address_internal(
768 dst_address.data(), dst_address.data() + dst_address.size());
769 return global_func_table_.wifi_start_sending_offloaded_packet(
770 cmd_id, getIfaceHandle(iface_name), ip_packet_data_internal.data(),
771 ip_packet_data_internal.size(), src_address_internal.data(),
772 dst_address_internal.data(), period_in_ms);
Roshan Pius9a9869a2017-01-11 16:42:16 -0800773}
774
Roshan Piusacededb2017-10-06 14:59:26 -0700775wifi_error WifiLegacyHal::stopSendingOffloadedPacket(
776 const std::string& iface_name, uint32_t cmd_id) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700777 return global_func_table_.wifi_stop_sending_offloaded_packet(
778 cmd_id, getIfaceHandle(iface_name));
Roshan Pius9a9869a2017-01-11 16:42:16 -0800779}
780
Roshan Piusabcf78f2017-10-06 16:30:38 -0700781wifi_error WifiLegacyHal::setScanningMacOui(const std::string& iface_name,
782 const std::array<uint8_t, 3>& oui) {
783 std::vector<uint8_t> oui_internal(oui.data(), oui.data() + oui.size());
784 return global_func_table_.wifi_set_scanning_mac_oui(
785 getIfaceHandle(iface_name), oui_internal.data());
Roshan Pius795bb812017-02-01 13:09:08 -0800786}
787
Roshan Piusabcf78f2017-10-06 16:30:38 -0700788wifi_error WifiLegacyHal::selectTxPowerScenario(const std::string& iface_name,
789 wifi_power_scenario scenario) {
790 return global_func_table_.wifi_select_tx_power_scenario(
791 getIfaceHandle(iface_name), scenario);
Roshan Pius8184d212017-07-11 08:59:29 -0700792}
793
Roshan Piusacededb2017-10-06 14:59:26 -0700794wifi_error WifiLegacyHal::resetTxPowerScenario(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700795 return global_func_table_.wifi_reset_tx_power_scenario(
796 getIfaceHandle(iface_name));
Roshan Pius8184d212017-07-11 08:59:29 -0700797}
798
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700799wifi_error WifiLegacyHal::setLatencyMode(const std::string& iface_name,
800 wifi_latency_mode mode) {
801 return global_func_table_.wifi_set_latency_mode(getIfaceHandle(iface_name),
802 mode);
803}
804
Roshan Piusacededb2017-10-06 14:59:26 -0700805std::pair<wifi_error, uint32_t> WifiLegacyHal::getLoggerSupportedFeatureSet(
806 const std::string& iface_name) {
Roshan Pius200a17d2017-11-01 13:03:35 -0700807 uint32_t supported_feature_flags;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700808 wifi_error status =
809 global_func_table_.wifi_get_logger_supported_feature_set(
Roshan Pius200a17d2017-11-01 13:03:35 -0700810 getIfaceHandle(iface_name), &supported_feature_flags);
811 return {status, supported_feature_flags};
Roshan Pius8714a3e2016-10-28 10:43:51 -0700812}
813
Roshan Piusacededb2017-10-06 14:59:26 -0700814wifi_error WifiLegacyHal::startPktFateMonitoring(
815 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700816 return global_func_table_.wifi_start_pkt_fate_monitoring(
817 getIfaceHandle(iface_name));
Roshan Pius8714a3e2016-10-28 10:43:51 -0700818}
819
Roshan Piusabcf78f2017-10-06 16:30:38 -0700820std::pair<wifi_error, std::vector<wifi_tx_report>> WifiLegacyHal::getTxPktFates(
821 const std::string& iface_name) {
822 std::vector<wifi_tx_report> tx_pkt_fates;
823 tx_pkt_fates.resize(MAX_FATE_LOG_LEN);
824 size_t num_fates = 0;
825 wifi_error status = global_func_table_.wifi_get_tx_pkt_fates(
826 getIfaceHandle(iface_name), tx_pkt_fates.data(), tx_pkt_fates.size(),
827 &num_fates);
828 CHECK(num_fates <= MAX_FATE_LOG_LEN);
829 tx_pkt_fates.resize(num_fates);
830 return {status, std::move(tx_pkt_fates)};
Roshan Pius8714a3e2016-10-28 10:43:51 -0700831}
832
Roshan Piusabcf78f2017-10-06 16:30:38 -0700833std::pair<wifi_error, std::vector<wifi_rx_report>> WifiLegacyHal::getRxPktFates(
834 const std::string& iface_name) {
835 std::vector<wifi_rx_report> rx_pkt_fates;
836 rx_pkt_fates.resize(MAX_FATE_LOG_LEN);
837 size_t num_fates = 0;
838 wifi_error status = global_func_table_.wifi_get_rx_pkt_fates(
839 getIfaceHandle(iface_name), rx_pkt_fates.data(), rx_pkt_fates.size(),
840 &num_fates);
841 CHECK(num_fates <= MAX_FATE_LOG_LEN);
842 rx_pkt_fates.resize(num_fates);
843 return {status, std::move(rx_pkt_fates)};
Roshan Pius8714a3e2016-10-28 10:43:51 -0700844}
845
Roshan Piusacededb2017-10-06 14:59:26 -0700846std::pair<wifi_error, WakeReasonStats> WifiLegacyHal::getWakeReasonStats(
847 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700848 WakeReasonStats stats;
849 stats.cmd_event_wake_cnt.resize(kMaxWakeReasonStatsArraySize);
850 stats.driver_fw_local_wake_cnt.resize(kMaxWakeReasonStatsArraySize);
Roshan Pius8714a3e2016-10-28 10:43:51 -0700851
Roshan Piusabcf78f2017-10-06 16:30:38 -0700852 // This legacy struct needs separate memory to store the variable sized wake
853 // reason types.
854 stats.wake_reason_cnt.cmd_event_wake_cnt =
855 reinterpret_cast<int32_t*>(stats.cmd_event_wake_cnt.data());
856 stats.wake_reason_cnt.cmd_event_wake_cnt_sz =
857 stats.cmd_event_wake_cnt.size();
858 stats.wake_reason_cnt.cmd_event_wake_cnt_used = 0;
859 stats.wake_reason_cnt.driver_fw_local_wake_cnt =
860 reinterpret_cast<int32_t*>(stats.driver_fw_local_wake_cnt.data());
861 stats.wake_reason_cnt.driver_fw_local_wake_cnt_sz =
862 stats.driver_fw_local_wake_cnt.size();
863 stats.wake_reason_cnt.driver_fw_local_wake_cnt_used = 0;
Roshan Pius8714a3e2016-10-28 10:43:51 -0700864
Roshan Piusabcf78f2017-10-06 16:30:38 -0700865 wifi_error status = global_func_table_.wifi_get_wake_reason_stats(
866 getIfaceHandle(iface_name), &stats.wake_reason_cnt);
Roshan Pius8714a3e2016-10-28 10:43:51 -0700867
Roshan Piusabcf78f2017-10-06 16:30:38 -0700868 CHECK(
869 stats.wake_reason_cnt.cmd_event_wake_cnt_used >= 0 &&
Roshan Pius8714a3e2016-10-28 10:43:51 -0700870 static_cast<uint32_t>(stats.wake_reason_cnt.cmd_event_wake_cnt_used) <=
871 kMaxWakeReasonStatsArraySize);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700872 stats.cmd_event_wake_cnt.resize(
873 stats.wake_reason_cnt.cmd_event_wake_cnt_used);
874 stats.wake_reason_cnt.cmd_event_wake_cnt = nullptr;
Roshan Pius8714a3e2016-10-28 10:43:51 -0700875
Roshan Piusabcf78f2017-10-06 16:30:38 -0700876 CHECK(stats.wake_reason_cnt.driver_fw_local_wake_cnt_used >= 0 &&
877 static_cast<uint32_t>(
878 stats.wake_reason_cnt.driver_fw_local_wake_cnt_used) <=
879 kMaxWakeReasonStatsArraySize);
880 stats.driver_fw_local_wake_cnt.resize(
881 stats.wake_reason_cnt.driver_fw_local_wake_cnt_used);
882 stats.wake_reason_cnt.driver_fw_local_wake_cnt = nullptr;
Roshan Pius8714a3e2016-10-28 10:43:51 -0700883
Roshan Piusabcf78f2017-10-06 16:30:38 -0700884 return {status, stats};
Roshan Pius8714a3e2016-10-28 10:43:51 -0700885}
886
887wifi_error WifiLegacyHal::registerRingBufferCallbackHandler(
Roshan Piusacededb2017-10-06 14:59:26 -0700888 const std::string& iface_name,
Roshan Pius8714a3e2016-10-28 10:43:51 -0700889 const on_ring_buffer_data_callback& on_user_data_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700890 if (on_ring_buffer_data_internal_callback) {
891 return WIFI_ERROR_NOT_AVAILABLE;
Roshan Pius8714a3e2016-10-28 10:43:51 -0700892 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700893 on_ring_buffer_data_internal_callback =
894 [on_user_data_callback](char* ring_name, char* buffer, int buffer_size,
895 wifi_ring_buffer_status* status) {
896 if (status && buffer) {
897 std::vector<uint8_t> buffer_vector(
898 reinterpret_cast<uint8_t*>(buffer),
899 reinterpret_cast<uint8_t*>(buffer) + buffer_size);
900 on_user_data_callback(ring_name, buffer_vector, *status);
901 }
902 };
903 wifi_error status = global_func_table_.wifi_set_log_handler(
904 0, getIfaceHandle(iface_name), {onAsyncRingBufferData});
905 if (status != WIFI_SUCCESS) {
906 on_ring_buffer_data_internal_callback = nullptr;
907 }
908 return status;
Roshan Piusadc87cb2016-12-14 18:02:56 -0800909}
910
Roshan Piusacededb2017-10-06 14:59:26 -0700911wifi_error WifiLegacyHal::deregisterRingBufferCallbackHandler(
912 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700913 if (!on_ring_buffer_data_internal_callback) {
914 return WIFI_ERROR_NOT_AVAILABLE;
915 }
916 on_ring_buffer_data_internal_callback = nullptr;
917 return global_func_table_.wifi_reset_log_handler(
918 0, getIfaceHandle(iface_name));
Roshan Pius8714a3e2016-10-28 10:43:51 -0700919}
920
921std::pair<wifi_error, std::vector<wifi_ring_buffer_status>>
Roshan Piusacededb2017-10-06 14:59:26 -0700922WifiLegacyHal::getRingBuffersStatus(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700923 std::vector<wifi_ring_buffer_status> ring_buffers_status;
924 ring_buffers_status.resize(kMaxRingBuffers);
925 uint32_t num_rings = kMaxRingBuffers;
926 wifi_error status = global_func_table_.wifi_get_ring_buffers_status(
927 getIfaceHandle(iface_name), &num_rings, ring_buffers_status.data());
928 CHECK(num_rings <= kMaxRingBuffers);
929 ring_buffers_status.resize(num_rings);
930 return {status, std::move(ring_buffers_status)};
Roshan Pius8714a3e2016-10-28 10:43:51 -0700931}
932
Roshan Piusabcf78f2017-10-06 16:30:38 -0700933wifi_error WifiLegacyHal::startRingBufferLogging(const std::string& iface_name,
934 const std::string& ring_name,
935 uint32_t verbose_level,
936 uint32_t max_interval_sec,
937 uint32_t min_data_size) {
938 return global_func_table_.wifi_start_logging(
939 getIfaceHandle(iface_name), verbose_level, 0, max_interval_sec,
940 min_data_size, makeCharVec(ring_name).data());
Roshan Pius8714a3e2016-10-28 10:43:51 -0700941}
942
Roshan Piusabcf78f2017-10-06 16:30:38 -0700943wifi_error WifiLegacyHal::getRingBufferData(const std::string& iface_name,
944 const std::string& ring_name) {
945 return global_func_table_.wifi_get_ring_data(getIfaceHandle(iface_name),
946 makeCharVec(ring_name).data());
Roshan Pius8714a3e2016-10-28 10:43:51 -0700947}
948
Roshan Pius203cb032016-12-14 17:41:20 -0800949wifi_error WifiLegacyHal::registerErrorAlertCallbackHandler(
Roshan Piusacededb2017-10-06 14:59:26 -0700950 const std::string& iface_name,
Roshan Pius203cb032016-12-14 17:41:20 -0800951 const on_error_alert_callback& on_user_alert_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700952 if (on_error_alert_internal_callback) {
953 return WIFI_ERROR_NOT_AVAILABLE;
Roshan Pius203cb032016-12-14 17:41:20 -0800954 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700955 on_error_alert_internal_callback = [on_user_alert_callback](
956 wifi_request_id id, char* buffer,
957 int buffer_size, int err_code) {
958 if (buffer) {
959 CHECK(id == 0);
960 on_user_alert_callback(
961 err_code,
962 std::vector<uint8_t>(
963 reinterpret_cast<uint8_t*>(buffer),
964 reinterpret_cast<uint8_t*>(buffer) + buffer_size));
965 }
966 };
967 wifi_error status = global_func_table_.wifi_set_alert_handler(
968 0, getIfaceHandle(iface_name), {onAsyncErrorAlert});
969 if (status != WIFI_SUCCESS) {
970 on_error_alert_internal_callback = nullptr;
971 }
972 return status;
Roshan Pius203cb032016-12-14 17:41:20 -0800973}
974
Roshan Piusacededb2017-10-06 14:59:26 -0700975wifi_error WifiLegacyHal::deregisterErrorAlertCallbackHandler(
976 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700977 if (!on_error_alert_internal_callback) {
978 return WIFI_ERROR_NOT_AVAILABLE;
979 }
980 on_error_alert_internal_callback = nullptr;
981 return global_func_table_.wifi_reset_alert_handler(
982 0, getIfaceHandle(iface_name));
Roshan Pius203cb032016-12-14 17:41:20 -0800983}
984
Roshan Pius01f08772018-01-22 17:56:06 -0800985wifi_error WifiLegacyHal::registerRadioModeChangeCallbackHandler(
986 const std::string& iface_name,
987 const on_radio_mode_change_callback& on_user_change_callback) {
988 if (on_radio_mode_change_internal_callback) {
989 return WIFI_ERROR_NOT_AVAILABLE;
990 }
991 on_radio_mode_change_internal_callback = [on_user_change_callback](
992 wifi_request_id /* id */,
993 uint32_t num_macs,
994 wifi_mac_info* mac_infos_arr) {
995 if (num_macs > 0 && mac_infos_arr) {
996 std::vector<WifiMacInfo> mac_infos_vec;
997 for (uint32_t i = 0; i < num_macs; i++) {
998 WifiMacInfo mac_info;
999 mac_info.wlan_mac_id = mac_infos_arr[i].wlan_mac_id;
1000 mac_info.mac_band = mac_infos_arr[i].mac_band;
1001 for (int32_t j = 0; j < mac_infos_arr[i].num_iface; j++) {
1002 WifiIfaceInfo iface_info;
1003 iface_info.name = mac_infos_arr[i].iface_info[j].iface_name;
1004 iface_info.channel = mac_infos_arr[i].iface_info[j].channel;
1005 mac_info.iface_infos.push_back(iface_info);
1006 }
1007 mac_infos_vec.push_back(mac_info);
1008 }
1009 on_user_change_callback(mac_infos_vec);
1010 }
1011 };
1012 wifi_error status = global_func_table_.wifi_set_radio_mode_change_handler(
1013 0, getIfaceHandle(iface_name), {onAsyncRadioModeChange});
1014 if (status != WIFI_SUCCESS) {
1015 on_radio_mode_change_internal_callback = nullptr;
1016 }
1017 return status;
1018}
1019
Roshan Piusd8e915a2016-10-28 11:23:11 -07001020wifi_error WifiLegacyHal::startRttRangeRequest(
Roshan Piusabcf78f2017-10-06 16:30:38 -07001021 const std::string& iface_name, wifi_request_id id,
Roshan Piusd8e915a2016-10-28 11:23:11 -07001022 const std::vector<wifi_rtt_config>& rtt_configs,
1023 const on_rtt_results_callback& on_results_user_callback) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001024 if (on_rtt_results_internal_callback) {
1025 return WIFI_ERROR_NOT_AVAILABLE;
Roshan Piusd8e915a2016-10-28 11:23:11 -07001026 }
Roshan Piusd8e915a2016-10-28 11:23:11 -07001027
Roshan Piusabcf78f2017-10-06 16:30:38 -07001028 on_rtt_results_internal_callback =
1029 [on_results_user_callback](wifi_request_id id, unsigned num_results,
1030 wifi_rtt_result* rtt_results[]) {
1031 if (num_results > 0 && !rtt_results) {
1032 LOG(ERROR) << "Unexpected nullptr in RTT results";
1033 return;
1034 }
1035 std::vector<const wifi_rtt_result*> rtt_results_vec;
1036 std::copy_if(rtt_results, rtt_results + num_results,
1037 back_inserter(rtt_results_vec),
1038 [](wifi_rtt_result* rtt_result) {
1039 return rtt_result != nullptr;
1040 });
1041 on_results_user_callback(id, rtt_results_vec);
1042 };
1043
1044 std::vector<wifi_rtt_config> rtt_configs_internal(rtt_configs);
1045 wifi_error status = global_func_table_.wifi_rtt_range_request(
1046 id, getIfaceHandle(iface_name), rtt_configs.size(),
1047 rtt_configs_internal.data(), {onAsyncRttResults});
1048 if (status != WIFI_SUCCESS) {
1049 on_rtt_results_internal_callback = nullptr;
1050 }
1051 return status;
Roshan Piusd8e915a2016-10-28 11:23:11 -07001052}
1053
1054wifi_error WifiLegacyHal::cancelRttRangeRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001055 const std::string& iface_name, wifi_request_id id,
1056 const std::vector<std::array<uint8_t, 6>>& mac_addrs) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001057 if (!on_rtt_results_internal_callback) {
1058 return WIFI_ERROR_NOT_AVAILABLE;
1059 }
1060 static_assert(sizeof(mac_addr) == sizeof(std::array<uint8_t, 6>),
1061 "MAC address size mismatch");
1062 // TODO: How do we handle partial cancels (i.e only a subset of enabled mac
1063 // addressed are cancelled).
1064 std::vector<std::array<uint8_t, 6>> mac_addrs_internal(mac_addrs);
1065 wifi_error status = global_func_table_.wifi_rtt_range_cancel(
1066 id, getIfaceHandle(iface_name), mac_addrs.size(),
1067 reinterpret_cast<mac_addr*>(mac_addrs_internal.data()));
1068 // If the request Id is wrong, don't stop the ongoing range request. Any
1069 // other error should be treated as the end of rtt ranging.
1070 if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
1071 on_rtt_results_internal_callback = nullptr;
1072 }
1073 return status;
Roshan Piusd8e915a2016-10-28 11:23:11 -07001074}
1075
Roshan Piusabcf78f2017-10-06 16:30:38 -07001076std::pair<wifi_error, wifi_rtt_capabilities> WifiLegacyHal::getRttCapabilities(
1077 const std::string& iface_name) {
1078 wifi_rtt_capabilities rtt_caps;
1079 wifi_error status = global_func_table_.wifi_get_rtt_capabilities(
1080 getIfaceHandle(iface_name), &rtt_caps);
1081 return {status, rtt_caps};
Roshan Piusd8e915a2016-10-28 11:23:11 -07001082}
1083
Roshan Piusacededb2017-10-06 14:59:26 -07001084std::pair<wifi_error, wifi_rtt_responder> WifiLegacyHal::getRttResponderInfo(
1085 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001086 wifi_rtt_responder rtt_responder;
1087 wifi_error status = global_func_table_.wifi_rtt_get_responder_info(
1088 getIfaceHandle(iface_name), &rtt_responder);
1089 return {status, rtt_responder};
Roshan Piusd8e915a2016-10-28 11:23:11 -07001090}
1091
1092wifi_error WifiLegacyHal::enableRttResponder(
Roshan Piusabcf78f2017-10-06 16:30:38 -07001093 const std::string& iface_name, wifi_request_id id,
1094 const wifi_channel_info& channel_hint, uint32_t max_duration_secs,
Roshan Piusd8e915a2016-10-28 11:23:11 -07001095 const wifi_rtt_responder& info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001096 wifi_rtt_responder info_internal(info);
1097 return global_func_table_.wifi_enable_responder(
1098 id, getIfaceHandle(iface_name), channel_hint, max_duration_secs,
1099 &info_internal);
Roshan Piusd8e915a2016-10-28 11:23:11 -07001100}
1101
Roshan Piusabcf78f2017-10-06 16:30:38 -07001102wifi_error WifiLegacyHal::disableRttResponder(const std::string& iface_name,
1103 wifi_request_id id) {
1104 return global_func_table_.wifi_disable_responder(
1105 id, getIfaceHandle(iface_name));
Roshan Piusd8e915a2016-10-28 11:23:11 -07001106}
1107
Roshan Piusabcf78f2017-10-06 16:30:38 -07001108wifi_error WifiLegacyHal::setRttLci(const std::string& iface_name,
1109 wifi_request_id id,
1110 const wifi_lci_information& info) {
1111 wifi_lci_information info_internal(info);
1112 return global_func_table_.wifi_set_lci(id, getIfaceHandle(iface_name),
1113 &info_internal);
Roshan Piusd8e915a2016-10-28 11:23:11 -07001114}
1115
Roshan Piusabcf78f2017-10-06 16:30:38 -07001116wifi_error WifiLegacyHal::setRttLcr(const std::string& iface_name,
1117 wifi_request_id id,
1118 const wifi_lcr_information& info) {
1119 wifi_lcr_information info_internal(info);
1120 return global_func_table_.wifi_set_lcr(id, getIfaceHandle(iface_name),
1121 &info_internal);
Roshan Piusd8e915a2016-10-28 11:23:11 -07001122}
1123
Roshan Pius23012092016-10-28 11:27:40 -07001124wifi_error WifiLegacyHal::nanRegisterCallbackHandlers(
Roshan Piusacededb2017-10-06 14:59:26 -07001125 const std::string& iface_name, const NanCallbackHandlers& user_callbacks) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001126 on_nan_notify_response_user_callback = user_callbacks.on_notify_response;
1127 on_nan_event_publish_terminated_user_callback =
1128 user_callbacks.on_event_publish_terminated;
1129 on_nan_event_match_user_callback = user_callbacks.on_event_match;
1130 on_nan_event_match_expired_user_callback =
1131 user_callbacks.on_event_match_expired;
1132 on_nan_event_subscribe_terminated_user_callback =
1133 user_callbacks.on_event_subscribe_terminated;
1134 on_nan_event_followup_user_callback = user_callbacks.on_event_followup;
1135 on_nan_event_disc_eng_event_user_callback =
1136 user_callbacks.on_event_disc_eng_event;
1137 on_nan_event_disabled_user_callback = user_callbacks.on_event_disabled;
1138 on_nan_event_tca_user_callback = user_callbacks.on_event_tca;
1139 on_nan_event_beacon_sdf_payload_user_callback =
1140 user_callbacks.on_event_beacon_sdf_payload;
1141 on_nan_event_data_path_request_user_callback =
1142 user_callbacks.on_event_data_path_request;
1143 on_nan_event_data_path_confirm_user_callback =
1144 user_callbacks.on_event_data_path_confirm;
1145 on_nan_event_data_path_end_user_callback =
1146 user_callbacks.on_event_data_path_end;
1147 on_nan_event_transmit_follow_up_user_callback =
1148 user_callbacks.on_event_transmit_follow_up;
1149 on_nan_event_range_request_user_callback =
1150 user_callbacks.on_event_range_request;
1151 on_nan_event_range_report_user_callback =
1152 user_callbacks.on_event_range_report;
Etan Cohen1bf15f12017-12-12 16:15:16 -08001153 on_nan_event_schedule_update_user_callback =
1154 user_callbacks.on_event_schedule_update;
Roshan Pius23012092016-10-28 11:27:40 -07001155
Roshan Piusabcf78f2017-10-06 16:30:38 -07001156 return global_func_table_.wifi_nan_register_handler(
1157 getIfaceHandle(iface_name),
1158 {onAysncNanNotifyResponse, onAysncNanEventPublishReplied,
1159 onAysncNanEventPublishTerminated, onAysncNanEventMatch,
1160 onAysncNanEventMatchExpired, onAysncNanEventSubscribeTerminated,
1161 onAysncNanEventFollowup, onAysncNanEventDiscEngEvent,
1162 onAysncNanEventDisabled, onAysncNanEventTca,
1163 onAysncNanEventBeaconSdfPayload, onAysncNanEventDataPathRequest,
1164 onAysncNanEventDataPathConfirm, onAysncNanEventDataPathEnd,
1165 onAysncNanEventTransmitFollowUp, onAysncNanEventRangeRequest,
Etan Cohen1bf15f12017-12-12 16:15:16 -08001166 onAysncNanEventRangeReport, onAsyncNanEventScheduleUpdate});
Roshan Pius23012092016-10-28 11:27:40 -07001167}
1168
Roshan Piusabcf78f2017-10-06 16:30:38 -07001169wifi_error WifiLegacyHal::nanEnableRequest(const std::string& iface_name,
1170 transaction_id id,
1171 const NanEnableRequest& msg) {
1172 NanEnableRequest msg_internal(msg);
1173 return global_func_table_.wifi_nan_enable_request(
1174 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001175}
1176
Roshan Piusabcf78f2017-10-06 16:30:38 -07001177wifi_error WifiLegacyHal::nanDisableRequest(const std::string& iface_name,
1178 transaction_id id) {
1179 return global_func_table_.wifi_nan_disable_request(
1180 id, getIfaceHandle(iface_name));
Roshan Pius23012092016-10-28 11:27:40 -07001181}
1182
Roshan Piusabcf78f2017-10-06 16:30:38 -07001183wifi_error WifiLegacyHal::nanPublishRequest(const std::string& iface_name,
1184 transaction_id id,
1185 const NanPublishRequest& msg) {
1186 NanPublishRequest msg_internal(msg);
1187 return global_func_table_.wifi_nan_publish_request(
1188 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001189}
1190
1191wifi_error WifiLegacyHal::nanPublishCancelRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001192 const std::string& iface_name, transaction_id id,
1193 const NanPublishCancelRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001194 NanPublishCancelRequest msg_internal(msg);
1195 return global_func_table_.wifi_nan_publish_cancel_request(
1196 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001197}
1198
Roshan Piusabcf78f2017-10-06 16:30:38 -07001199wifi_error WifiLegacyHal::nanSubscribeRequest(const std::string& iface_name,
1200 transaction_id id,
1201 const NanSubscribeRequest& msg) {
1202 NanSubscribeRequest msg_internal(msg);
1203 return global_func_table_.wifi_nan_subscribe_request(
1204 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001205}
1206
1207wifi_error WifiLegacyHal::nanSubscribeCancelRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001208 const std::string& iface_name, transaction_id id,
1209 const NanSubscribeCancelRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001210 NanSubscribeCancelRequest msg_internal(msg);
1211 return global_func_table_.wifi_nan_subscribe_cancel_request(
1212 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001213}
1214
1215wifi_error WifiLegacyHal::nanTransmitFollowupRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001216 const std::string& iface_name, transaction_id id,
1217 const NanTransmitFollowupRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001218 NanTransmitFollowupRequest msg_internal(msg);
1219 return global_func_table_.wifi_nan_transmit_followup_request(
1220 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001221}
1222
Roshan Piusabcf78f2017-10-06 16:30:38 -07001223wifi_error WifiLegacyHal::nanStatsRequest(const std::string& iface_name,
1224 transaction_id id,
1225 const NanStatsRequest& msg) {
1226 NanStatsRequest msg_internal(msg);
1227 return global_func_table_.wifi_nan_stats_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::nanConfigRequest(const std::string& iface_name,
1232 transaction_id id,
1233 const NanConfigRequest& msg) {
1234 NanConfigRequest msg_internal(msg);
1235 return global_func_table_.wifi_nan_config_request(
1236 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001237}
1238
Roshan Piusabcf78f2017-10-06 16:30:38 -07001239wifi_error WifiLegacyHal::nanTcaRequest(const std::string& iface_name,
1240 transaction_id id,
1241 const NanTCARequest& msg) {
1242 NanTCARequest msg_internal(msg);
1243 return global_func_table_.wifi_nan_tca_request(
1244 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001245}
1246
1247wifi_error WifiLegacyHal::nanBeaconSdfPayloadRequest(
Roshan Piusacededb2017-10-06 14:59:26 -07001248 const std::string& iface_name, transaction_id id,
1249 const NanBeaconSdfPayloadRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001250 NanBeaconSdfPayloadRequest msg_internal(msg);
1251 return global_func_table_.wifi_nan_beacon_sdf_payload_request(
1252 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001253}
1254
1255std::pair<wifi_error, NanVersion> WifiLegacyHal::nanGetVersion() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001256 NanVersion version;
1257 wifi_error status =
1258 global_func_table_.wifi_nan_get_version(global_handle_, &version);
1259 return {status, version};
Roshan Pius23012092016-10-28 11:27:40 -07001260}
1261
Roshan Piusabcf78f2017-10-06 16:30:38 -07001262wifi_error WifiLegacyHal::nanGetCapabilities(const std::string& iface_name,
1263 transaction_id id) {
1264 return global_func_table_.wifi_nan_get_capabilities(
1265 id, getIfaceHandle(iface_name));
Roshan Pius23012092016-10-28 11:27:40 -07001266}
1267
1268wifi_error WifiLegacyHal::nanDataInterfaceCreate(
Roshan Piusacededb2017-10-06 14:59:26 -07001269 const std::string& iface_name, transaction_id id,
1270 const std::string& data_iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001271 return global_func_table_.wifi_nan_data_interface_create(
1272 id, getIfaceHandle(iface_name), makeCharVec(data_iface_name).data());
Roshan Pius23012092016-10-28 11:27:40 -07001273}
1274
1275wifi_error WifiLegacyHal::nanDataInterfaceDelete(
Roshan Piusacededb2017-10-06 14:59:26 -07001276 const std::string& iface_name, transaction_id id,
1277 const std::string& data_iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001278 return global_func_table_.wifi_nan_data_interface_delete(
1279 id, getIfaceHandle(iface_name), makeCharVec(data_iface_name).data());
Roshan Pius23012092016-10-28 11:27:40 -07001280}
1281
1282wifi_error WifiLegacyHal::nanDataRequestInitiator(
Roshan Piusacededb2017-10-06 14:59:26 -07001283 const std::string& iface_name, transaction_id id,
1284 const NanDataPathInitiatorRequest& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001285 NanDataPathInitiatorRequest msg_internal(msg);
1286 return global_func_table_.wifi_nan_data_request_initiator(
1287 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001288}
1289
1290wifi_error WifiLegacyHal::nanDataIndicationResponse(
Roshan Piusacededb2017-10-06 14:59:26 -07001291 const std::string& iface_name, transaction_id id,
1292 const NanDataPathIndicationResponse& msg) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001293 NanDataPathIndicationResponse msg_internal(msg);
1294 return global_func_table_.wifi_nan_data_indication_response(
1295 id, getIfaceHandle(iface_name), &msg_internal);
Roshan Pius23012092016-10-28 11:27:40 -07001296}
1297
Etan Cohenc9836f92017-06-30 13:55:21 -07001298typedef struct {
1299 u8 num_ndp_instances;
1300 NanDataPathId ndp_instance_id;
1301} NanDataPathEndSingleNdpIdRequest;
1302
Roshan Piusabcf78f2017-10-06 16:30:38 -07001303wifi_error WifiLegacyHal::nanDataEnd(const std::string& iface_name,
1304 transaction_id id,
1305 uint32_t ndpInstanceId) {
1306 NanDataPathEndSingleNdpIdRequest msg;
1307 msg.num_ndp_instances = 1;
1308 msg.ndp_instance_id = ndpInstanceId;
1309 wifi_error status = global_func_table_.wifi_nan_data_end(
1310 id, getIfaceHandle(iface_name), (NanDataPathEndRequest*)&msg);
1311 return status;
Roshan Pius23012092016-10-28 11:27:40 -07001312}
1313
Roshan Piusabcf78f2017-10-06 16:30:38 -07001314wifi_error WifiLegacyHal::setCountryCode(const std::string& iface_name,
1315 std::array<int8_t, 2> code) {
1316 std::string code_str(code.data(), code.data() + code.size());
1317 return global_func_table_.wifi_set_country_code(getIfaceHandle(iface_name),
1318 code_str.c_str());
Roshan Pius32fc12e2017-01-25 17:44:42 -08001319}
1320
Roshan Piusacededb2017-10-06 14:59:26 -07001321wifi_error WifiLegacyHal::retrieveIfaceHandles() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001322 wifi_interface_handle* iface_handles = nullptr;
1323 int num_iface_handles = 0;
1324 wifi_error status = global_func_table_.wifi_get_ifaces(
1325 global_handle_, &num_iface_handles, &iface_handles);
Roshan Piusaabe5752016-09-29 09:03:59 -07001326 if (status != WIFI_SUCCESS) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001327 LOG(ERROR) << "Failed to enumerate interface handles";
1328 return status;
Roshan Piusaabe5752016-09-29 09:03:59 -07001329 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001330 for (int i = 0; i < num_iface_handles; ++i) {
1331 std::array<char, IFNAMSIZ> iface_name_arr = {};
1332 status = global_func_table_.wifi_get_iface_name(
1333 iface_handles[i], iface_name_arr.data(), iface_name_arr.size());
1334 if (status != WIFI_SUCCESS) {
1335 LOG(WARNING) << "Failed to get interface handle name";
1336 continue;
1337 }
1338 // Assuming the interface name is null terminated since the legacy HAL
1339 // API does not return a size.
1340 std::string iface_name(iface_name_arr.data());
1341 LOG(INFO) << "Adding interface handle for " << iface_name;
1342 iface_name_to_handle_[iface_name] = iface_handles[i];
1343 }
1344 return WIFI_SUCCESS;
Roshan Piusacededb2017-10-06 14:59:26 -07001345}
1346
1347wifi_interface_handle WifiLegacyHal::getIfaceHandle(
1348 const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001349 const auto iface_handle_iter = iface_name_to_handle_.find(iface_name);
1350 if (iface_handle_iter == iface_name_to_handle_.end()) {
1351 LOG(ERROR) << "Unknown iface name: " << iface_name;
1352 return nullptr;
1353 }
1354 return iface_handle_iter->second;
Roshan Piusaabe5752016-09-29 09:03:59 -07001355}
1356
1357void WifiLegacyHal::runEventLoop() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001358 LOG(DEBUG) << "Starting legacy HAL event loop";
1359 global_func_table_.wifi_event_loop(global_handle_);
1360 const auto lock = hidl_sync_util::acquireGlobalLock();
1361 if (!awaiting_event_loop_termination_) {
1362 LOG(FATAL)
1363 << "Legacy HAL event loop terminated, but HAL was not stopping";
1364 }
1365 LOG(DEBUG) << "Legacy HAL event loop terminated";
1366 awaiting_event_loop_termination_ = false;
1367 stop_wait_cv_.notify_one();
Roshan Piusaabe5752016-09-29 09:03:59 -07001368}
1369
Roshan Pius76ff3022016-10-28 10:33:34 -07001370std::pair<wifi_error, std::vector<wifi_cached_scan_results>>
Roshan Piusacededb2017-10-06 14:59:26 -07001371WifiLegacyHal::getGscanCachedResults(const std::string& iface_name) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001372 std::vector<wifi_cached_scan_results> cached_scan_results;
1373 cached_scan_results.resize(kMaxCachedGscanResults);
1374 int32_t num_results = 0;
1375 wifi_error status = global_func_table_.wifi_get_cached_gscan_results(
1376 getIfaceHandle(iface_name), true /* always flush */,
1377 cached_scan_results.size(), cached_scan_results.data(), &num_results);
1378 CHECK(num_results >= 0 &&
1379 static_cast<uint32_t>(num_results) <= kMaxCachedGscanResults);
1380 cached_scan_results.resize(num_results);
1381 // Check for invalid IE lengths in these cached scan results and correct it.
1382 for (auto& cached_scan_result : cached_scan_results) {
1383 int num_scan_results = cached_scan_result.num_results;
1384 for (int i = 0; i < num_scan_results; i++) {
1385 auto& scan_result = cached_scan_result.results[i];
1386 if (scan_result.ie_length > 0) {
1387 LOG(DEBUG) << "Cached scan result has non-zero IE length "
1388 << scan_result.ie_length;
1389 scan_result.ie_length = 0;
1390 }
1391 }
Roshan Pius76ff3022016-10-28 10:33:34 -07001392 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001393 return {status, std::move(cached_scan_results)};
Roshan Pius76ff3022016-10-28 10:33:34 -07001394}
1395
Roshan Pius511cc492016-10-28 09:54:26 -07001396void WifiLegacyHal::invalidate() {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001397 global_handle_ = nullptr;
1398 iface_name_to_handle_.clear();
1399 on_driver_memory_dump_internal_callback = nullptr;
1400 on_firmware_memory_dump_internal_callback = nullptr;
1401 on_gscan_event_internal_callback = nullptr;
1402 on_gscan_full_result_internal_callback = nullptr;
1403 on_link_layer_stats_result_internal_callback = nullptr;
1404 on_rssi_threshold_breached_internal_callback = nullptr;
1405 on_ring_buffer_data_internal_callback = nullptr;
1406 on_error_alert_internal_callback = nullptr;
Roshan Pius01f08772018-01-22 17:56:06 -08001407 on_radio_mode_change_internal_callback = nullptr;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001408 on_rtt_results_internal_callback = nullptr;
1409 on_nan_notify_response_user_callback = nullptr;
1410 on_nan_event_publish_terminated_user_callback = nullptr;
1411 on_nan_event_match_user_callback = nullptr;
1412 on_nan_event_match_expired_user_callback = nullptr;
1413 on_nan_event_subscribe_terminated_user_callback = nullptr;
1414 on_nan_event_followup_user_callback = nullptr;
1415 on_nan_event_disc_eng_event_user_callback = nullptr;
1416 on_nan_event_disabled_user_callback = nullptr;
1417 on_nan_event_tca_user_callback = nullptr;
1418 on_nan_event_beacon_sdf_payload_user_callback = nullptr;
1419 on_nan_event_data_path_request_user_callback = nullptr;
1420 on_nan_event_data_path_confirm_user_callback = nullptr;
1421 on_nan_event_data_path_end_user_callback = nullptr;
1422 on_nan_event_transmit_follow_up_user_callback = nullptr;
1423 on_nan_event_range_request_user_callback = nullptr;
1424 on_nan_event_range_report_user_callback = nullptr;
Etan Cohen1bf15f12017-12-12 16:15:16 -08001425 on_nan_event_schedule_update_user_callback = nullptr;
Roshan Pius511cc492016-10-28 09:54:26 -07001426}
Roshan Pius955542e2016-10-28 09:42:44 -07001427
1428} // namespace legacy_hal
Roshan Piusaabe5752016-09-29 09:03:59 -07001429} // namespace implementation
Jong Wook Kimda830c92018-07-23 15:29:38 -07001430} // namespace V1_3
Roshan Piusaabe5752016-09-29 09:03:59 -07001431} // namespace wifi
1432} // namespace hardware
1433} // namespace android