1 /*
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 */
17 #include <array>
18 #include <chrono>
20 #include <android-base/logging.h>
22 #include "hidl_sync_util.h"
23 #include "wifi_legacy_hal.h"
24 #include "wifi_legacy_hal_stubs.h"
26 namespace {
27 // Constants ported over from the legacy HAL calling code
28 // (com_android_server_wifi_WifiNative.cpp). This will all be thrown
29 // away when this shim layer is replaced by the real vendor
30 // implementation.
31 static constexpr uint32_t kMaxVersionStringLength = 256;
32 static constexpr uint32_t kMaxCachedGscanResults = 64;
33 static constexpr uint32_t kMaxGscanFrequenciesForBand = 64;
34 static constexpr uint32_t kLinkLayerStatsDataMpduSizeThreshold = 128;
35 static constexpr uint32_t kMaxWakeReasonStatsArraySize = 32;
36 static constexpr uint32_t kMaxRingBuffers = 10;
37 static constexpr uint32_t kMaxStopCompleteWaitMs = 100;
39 // Helper function to create a non-const char* for legacy Hal API's.
40 std::vector<char> makeCharVec(const std::string& str) {
41 std::vector<char> vec(str.size() + 1);
42 vec.assign(str.begin(), str.end());
43 vec.push_back('\0');
44 return vec;
45 }
46 } // namespace
48 namespace android {
49 namespace hardware {
50 namespace wifi {
51 namespace V1_2 {
52 namespace implementation {
53 namespace legacy_hal {
54 // Legacy HAL functions accept "C" style function pointers, so use global
55 // functions to pass to the legacy HAL function and store the corresponding
56 // std::function methods to be invoked.
57 //
58 // Callback to be invoked once |stop| is complete
59 std::function<void(wifi_handle handle)> on_stop_complete_internal_callback;
60 void onAsyncStopComplete(wifi_handle handle) {
61 const auto lock = hidl_sync_util::acquireGlobalLock();
62 if (on_stop_complete_internal_callback) {
63 on_stop_complete_internal_callback(handle);
64 // Invalidate this callback since we don't want this firing again.
65 on_stop_complete_internal_callback = nullptr;
66 }
67 }
69 // Callback to be invoked for driver dump.
70 std::function<void(char*, int)> on_driver_memory_dump_internal_callback;
71 void onSyncDriverMemoryDump(char* buffer, int buffer_size) {
72 if (on_driver_memory_dump_internal_callback) {
73 on_driver_memory_dump_internal_callback(buffer, buffer_size);
74 }
75 }
77 // Callback to be invoked for firmware dump.
78 std::function<void(char*, int)> on_firmware_memory_dump_internal_callback;
79 void onSyncFirmwareMemoryDump(char* buffer, int buffer_size) {
80 if (on_firmware_memory_dump_internal_callback) {
81 on_firmware_memory_dump_internal_callback(buffer, buffer_size);
82 }
83 }
85 // Callback to be invoked for Gscan events.
86 std::function<void(wifi_request_id, wifi_scan_event)>
87 on_gscan_event_internal_callback;
88 void onAsyncGscanEvent(wifi_request_id id, wifi_scan_event event) {
89 const auto lock = hidl_sync_util::acquireGlobalLock();
90 if (on_gscan_event_internal_callback) {
91 on_gscan_event_internal_callback(id, event);
92 }
93 }
95 // Callback to be invoked for Gscan full results.
96 std::function<void(wifi_request_id, wifi_scan_result*, uint32_t)>
97 on_gscan_full_result_internal_callback;
98 void onAsyncGscanFullResult(wifi_request_id id, wifi_scan_result* result,
99 uint32_t buckets_scanned) {
100 const auto lock = hidl_sync_util::acquireGlobalLock();
101 if (on_gscan_full_result_internal_callback) {
102 on_gscan_full_result_internal_callback(id, result, buckets_scanned);
103 }
104 }
106 // Callback to be invoked for link layer stats results.
107 std::function<void((wifi_request_id, wifi_iface_stat*, int, wifi_radio_stat*))>
108 on_link_layer_stats_result_internal_callback;
109 void onSyncLinkLayerStatsResult(wifi_request_id id, wifi_iface_stat* iface_stat,
110 int num_radios, wifi_radio_stat* radio_stat) {
111 if (on_link_layer_stats_result_internal_callback) {
112 on_link_layer_stats_result_internal_callback(id, iface_stat, num_radios,
113 radio_stat);
114 }
115 }
117 // Callback to be invoked for rssi threshold breach.
118 std::function<void((wifi_request_id, uint8_t*, int8_t))>
119 on_rssi_threshold_breached_internal_callback;
120 void onAsyncRssiThresholdBreached(wifi_request_id id, uint8_t* bssid,
121 int8_t rssi) {
122 const auto lock = hidl_sync_util::acquireGlobalLock();
123 if (on_rssi_threshold_breached_internal_callback) {
124 on_rssi_threshold_breached_internal_callback(id, bssid, rssi);
125 }
126 }
128 // Callback to be invoked for ring buffer data indication.
129 std::function<void(char*, char*, int, wifi_ring_buffer_status*)>
130 on_ring_buffer_data_internal_callback;
131 void onAsyncRingBufferData(char* ring_name, char* buffer, int buffer_size,
132 wifi_ring_buffer_status* status) {
133 const auto lock = hidl_sync_util::acquireGlobalLock();
134 if (on_ring_buffer_data_internal_callback) {
135 on_ring_buffer_data_internal_callback(ring_name, buffer, buffer_size,
136 status);
137 }
138 }
140 // Callback to be invoked for error alert indication.
141 std::function<void(wifi_request_id, char*, int, int)>
142 on_error_alert_internal_callback;
143 void onAsyncErrorAlert(wifi_request_id id, char* buffer, int buffer_size,
144 int err_code) {
145 const auto lock = hidl_sync_util::acquireGlobalLock();
146 if (on_error_alert_internal_callback) {
147 on_error_alert_internal_callback(id, buffer, buffer_size, err_code);
148 }
149 }
151 // Callback to be invoked for radio mode change indication.
152 std::function<void(wifi_request_id, uint32_t, wifi_mac_info*)>
153 on_radio_mode_change_internal_callback;
154 void onAsyncRadioModeChange(wifi_request_id id, uint32_t num_macs,
155 wifi_mac_info* mac_infos) {
156 const auto lock = hidl_sync_util::acquireGlobalLock();
157 if (on_radio_mode_change_internal_callback) {
158 on_radio_mode_change_internal_callback(id, num_macs, mac_infos);
159 }
160 }
162 // Callback to be invoked for rtt results results.
163 std::function<void(wifi_request_id, unsigned num_results,
164 wifi_rtt_result* rtt_results[])>
165 on_rtt_results_internal_callback;
166 void onAsyncRttResults(wifi_request_id id, unsigned num_results,
167 wifi_rtt_result* rtt_results[]) {
168 const auto lock = hidl_sync_util::acquireGlobalLock();
169 if (on_rtt_results_internal_callback) {
170 on_rtt_results_internal_callback(id, num_results, rtt_results);
171 on_rtt_results_internal_callback = nullptr;
172 }
173 }
175 // Callbacks for the various NAN operations.
176 // NOTE: These have very little conversions to perform before invoking the user
177 // callbacks.
178 // So, handle all of them here directly to avoid adding an unnecessary layer.
179 std::function<void(transaction_id, const NanResponseMsg&)>
180 on_nan_notify_response_user_callback;
181 void onAysncNanNotifyResponse(transaction_id id, NanResponseMsg* msg) {
182 const auto lock = hidl_sync_util::acquireGlobalLock();
183 if (on_nan_notify_response_user_callback && msg) {
184 on_nan_notify_response_user_callback(id, *msg);
185 }
186 }
188 std::function<void(const NanPublishRepliedInd&)>
189 on_nan_event_publish_replied_user_callback;
190 void onAysncNanEventPublishReplied(NanPublishRepliedInd* /* event */) {
191 LOG(ERROR) << "onAysncNanEventPublishReplied triggered";
192 }
194 std::function<void(const NanPublishTerminatedInd&)>
195 on_nan_event_publish_terminated_user_callback;
196 void onAysncNanEventPublishTerminated(NanPublishTerminatedInd* event) {
197 const auto lock = hidl_sync_util::acquireGlobalLock();
198 if (on_nan_event_publish_terminated_user_callback && event) {
199 on_nan_event_publish_terminated_user_callback(*event);
200 }
201 }
203 std::function<void(const NanMatchInd&)> on_nan_event_match_user_callback;
204 void onAysncNanEventMatch(NanMatchInd* event) {
205 const auto lock = hidl_sync_util::acquireGlobalLock();
206 if (on_nan_event_match_user_callback && event) {
207 on_nan_event_match_user_callback(*event);
208 }
209 }
211 std::function<void(const NanMatchExpiredInd&)>
212 on_nan_event_match_expired_user_callback;
213 void onAysncNanEventMatchExpired(NanMatchExpiredInd* event) {
214 const auto lock = hidl_sync_util::acquireGlobalLock();
215 if (on_nan_event_match_expired_user_callback && event) {
216 on_nan_event_match_expired_user_callback(*event);
217 }
218 }
220 std::function<void(const NanSubscribeTerminatedInd&)>
221 on_nan_event_subscribe_terminated_user_callback;
222 void onAysncNanEventSubscribeTerminated(NanSubscribeTerminatedInd* event) {
223 const auto lock = hidl_sync_util::acquireGlobalLock();
224 if (on_nan_event_subscribe_terminated_user_callback && event) {
225 on_nan_event_subscribe_terminated_user_callback(*event);
226 }
227 }
229 std::function<void(const NanFollowupInd&)> on_nan_event_followup_user_callback;
230 void onAysncNanEventFollowup(NanFollowupInd* event) {
231 const auto lock = hidl_sync_util::acquireGlobalLock();
232 if (on_nan_event_followup_user_callback && event) {
233 on_nan_event_followup_user_callback(*event);
234 }
235 }
237 std::function<void(const NanDiscEngEventInd&)>
238 on_nan_event_disc_eng_event_user_callback;
239 void onAysncNanEventDiscEngEvent(NanDiscEngEventInd* event) {
240 const auto lock = hidl_sync_util::acquireGlobalLock();
241 if (on_nan_event_disc_eng_event_user_callback && event) {
242 on_nan_event_disc_eng_event_user_callback(*event);
243 }
244 }
246 std::function<void(const NanDisabledInd&)> on_nan_event_disabled_user_callback;
247 void onAysncNanEventDisabled(NanDisabledInd* event) {
248 const auto lock = hidl_sync_util::acquireGlobalLock();
249 if (on_nan_event_disabled_user_callback && event) {
250 on_nan_event_disabled_user_callback(*event);
251 }
252 }
254 std::function<void(const NanTCAInd&)> on_nan_event_tca_user_callback;
255 void onAysncNanEventTca(NanTCAInd* event) {
256 const auto lock = hidl_sync_util::acquireGlobalLock();
257 if (on_nan_event_tca_user_callback && event) {
258 on_nan_event_tca_user_callback(*event);
259 }
260 }
262 std::function<void(const NanBeaconSdfPayloadInd&)>
263 on_nan_event_beacon_sdf_payload_user_callback;
264 void onAysncNanEventBeaconSdfPayload(NanBeaconSdfPayloadInd* event) {
265 const auto lock = hidl_sync_util::acquireGlobalLock();
266 if (on_nan_event_beacon_sdf_payload_user_callback && event) {
267 on_nan_event_beacon_sdf_payload_user_callback(*event);
268 }
269 }
271 std::function<void(const NanDataPathRequestInd&)>
272 on_nan_event_data_path_request_user_callback;
273 void onAysncNanEventDataPathRequest(NanDataPathRequestInd* event) {
274 const auto lock = hidl_sync_util::acquireGlobalLock();
275 if (on_nan_event_data_path_request_user_callback && event) {
276 on_nan_event_data_path_request_user_callback(*event);
277 }
278 }
279 std::function<void(const NanDataPathConfirmInd&)>
280 on_nan_event_data_path_confirm_user_callback;
281 void onAysncNanEventDataPathConfirm(NanDataPathConfirmInd* event) {
282 const auto lock = hidl_sync_util::acquireGlobalLock();
283 if (on_nan_event_data_path_confirm_user_callback && event) {
284 on_nan_event_data_path_confirm_user_callback(*event);
285 }
286 }
288 std::function<void(const NanDataPathEndInd&)>
289 on_nan_event_data_path_end_user_callback;
290 void onAysncNanEventDataPathEnd(NanDataPathEndInd* event) {
291 const auto lock = hidl_sync_util::acquireGlobalLock();
292 if (on_nan_event_data_path_end_user_callback && event) {
293 on_nan_event_data_path_end_user_callback(*event);
294 }
295 }
297 std::function<void(const NanTransmitFollowupInd&)>
298 on_nan_event_transmit_follow_up_user_callback;
299 void onAysncNanEventTransmitFollowUp(NanTransmitFollowupInd* event) {
300 const auto lock = hidl_sync_util::acquireGlobalLock();
301 if (on_nan_event_transmit_follow_up_user_callback && event) {
302 on_nan_event_transmit_follow_up_user_callback(*event);
303 }
304 }
306 std::function<void(const NanRangeRequestInd&)>
307 on_nan_event_range_request_user_callback;
308 void onAysncNanEventRangeRequest(NanRangeRequestInd* event) {
309 const auto lock = hidl_sync_util::acquireGlobalLock();
310 if (on_nan_event_range_request_user_callback && event) {
311 on_nan_event_range_request_user_callback(*event);
312 }
313 }
315 std::function<void(const NanRangeReportInd&)>
316 on_nan_event_range_report_user_callback;
317 void onAysncNanEventRangeReport(NanRangeReportInd* event) {
318 const auto lock = hidl_sync_util::acquireGlobalLock();
319 if (on_nan_event_range_report_user_callback && event) {
320 on_nan_event_range_report_user_callback(*event);
321 }
322 }
324 std::function<void(const NanDataPathScheduleUpdateInd&)>
325 on_nan_event_schedule_update_user_callback;
326 void onAsyncNanEventScheduleUpdate(NanDataPathScheduleUpdateInd* event) {
327 const auto lock = hidl_sync_util::acquireGlobalLock();
328 if (on_nan_event_schedule_update_user_callback && event) {
329 on_nan_event_schedule_update_user_callback(*event);
330 }
331 }
332 // End of the free-standing "C" style callbacks.
334 WifiLegacyHal::WifiLegacyHal()
335 : global_handle_(nullptr),
336 awaiting_event_loop_termination_(false),
337 is_started_(false) {}
339 wifi_error WifiLegacyHal::initialize() {
340 LOG(DEBUG) << "Initialize legacy HAL";
341 // TODO: Add back the HAL Tool if we need to. All we need from the HAL tool
342 // for now is this function call which we can directly call.
343 if (!initHalFuncTableWithStubs(&global_func_table_)) {
344 LOG(ERROR)
345 << "Failed to initialize legacy hal function table with stubs";
346 return WIFI_ERROR_UNKNOWN;
347 }
348 wifi_error status = init_wifi_vendor_hal_func_table(&global_func_table_);
349 if (status != WIFI_SUCCESS) {
350 LOG(ERROR) << "Failed to initialize legacy hal function table";
351 }
352 return status;
353 }
355 wifi_error WifiLegacyHal::start() {
356 // Ensure that we're starting in a good state.
357 CHECK(global_func_table_.wifi_initialize && !global_handle_ &&
358 iface_name_to_handle_.empty() && !awaiting_event_loop_termination_);
359 if (is_started_) {
360 LOG(DEBUG) << "Legacy HAL already started";
361 return WIFI_SUCCESS;
362 }
363 LOG(DEBUG) << "Waiting for the driver ready";
364 wifi_error status = global_func_table_.wifi_wait_for_driver_ready();
365 if (status == WIFI_ERROR_TIMED_OUT) {
366 LOG(ERROR) << "Timed out awaiting driver ready";
367 return status;
368 }
369 LOG(DEBUG) << "Starting legacy HAL";
370 if (!iface_tool_.SetWifiUpState(true)) {
371 LOG(ERROR) << "Failed to set WiFi interface up";
372 return WIFI_ERROR_UNKNOWN;
373 }
374 status = global_func_table_.wifi_initialize(&global_handle_);
375 if (status != WIFI_SUCCESS || !global_handle_) {
376 LOG(ERROR) << "Failed to retrieve global handle";
377 return status;
378 }
379 std::thread(&WifiLegacyHal::runEventLoop, this).detach();
380 status = retrieveIfaceHandles();
381 if (status != WIFI_SUCCESS || iface_name_to_handle_.empty()) {
382 LOG(ERROR) << "Failed to retrieve wlan interface handle";
383 return status;
384 }
385 LOG(DEBUG) << "Legacy HAL start complete";
386 is_started_ = true;
387 return WIFI_SUCCESS;
388 }
390 wifi_error WifiLegacyHal::stop(
391 /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock,
392 const std::function<void()>& on_stop_complete_user_callback) {
393 if (!is_started_) {
394 LOG(DEBUG) << "Legacy HAL already stopped";
395 on_stop_complete_user_callback();
396 return WIFI_SUCCESS;
397 }
398 LOG(DEBUG) << "Stopping legacy HAL";
399 on_stop_complete_internal_callback = [on_stop_complete_user_callback,
400 this](wifi_handle handle) {
401 CHECK_EQ(global_handle_, handle) << "Handle mismatch";
402 LOG(INFO) << "Legacy HAL stop complete callback received";
403 // Invalidate all the internal pointers now that the HAL is
404 // stopped.
405 invalidate();
406 iface_tool_.SetWifiUpState(false);
407 on_stop_complete_user_callback();
408 is_started_ = false;
409 };
410 awaiting_event_loop_termination_ = true;
411 global_func_table_.wifi_cleanup(global_handle_, onAsyncStopComplete);
412 const auto status = stop_wait_cv_.wait_for(
413 *lock, std::chrono::milliseconds(kMaxStopCompleteWaitMs),
414 [this] { return !awaiting_event_loop_termination_; });
415 if (!status) {
416 LOG(ERROR) << "Legacy HAL stop failed or timed out";
417 return WIFI_ERROR_UNKNOWN;
418 }
419 LOG(DEBUG) << "Legacy HAL stop complete";
420 return WIFI_SUCCESS;
421 }
423 std::pair<wifi_error, std::string> WifiLegacyHal::getDriverVersion(
424 const std::string& iface_name) {
425 std::array<char, kMaxVersionStringLength> buffer;
426 buffer.fill(0);
427 wifi_error status = global_func_table_.wifi_get_driver_version(
428 getIfaceHandle(iface_name), buffer.data(), buffer.size());
429 return {status, buffer.data()};
430 }
432 std::pair<wifi_error, std::string> WifiLegacyHal::getFirmwareVersion(
433 const std::string& iface_name) {
434 std::array<char, kMaxVersionStringLength> buffer;
435 buffer.fill(0);
436 wifi_error status = global_func_table_.wifi_get_firmware_version(
437 getIfaceHandle(iface_name), buffer.data(), buffer.size());
438 return {status, buffer.data()};
439 }
441 std::pair<wifi_error, std::vector<uint8_t>>
442 WifiLegacyHal::requestDriverMemoryDump(const std::string& iface_name) {
443 std::vector<uint8_t> driver_dump;
444 on_driver_memory_dump_internal_callback = [&driver_dump](char* buffer,
445 int buffer_size) {
446 driver_dump.insert(driver_dump.end(),
447 reinterpret_cast<uint8_t*>(buffer),
448 reinterpret_cast<uint8_t*>(buffer) + buffer_size);
449 };
450 wifi_error status = global_func_table_.wifi_get_driver_memory_dump(
451 getIfaceHandle(iface_name), {onSyncDriverMemoryDump});
452 on_driver_memory_dump_internal_callback = nullptr;
453 return {status, std::move(driver_dump)};
454 }
456 std::pair<wifi_error, std::vector<uint8_t>>
457 WifiLegacyHal::requestFirmwareMemoryDump(const std::string& iface_name) {
458 std::vector<uint8_t> firmware_dump;
459 on_firmware_memory_dump_internal_callback =
460 [&firmware_dump](char* buffer, int buffer_size) {
461 firmware_dump.insert(
462 firmware_dump.end(), reinterpret_cast<uint8_t*>(buffer),
463 reinterpret_cast<uint8_t*>(buffer) + buffer_size);
464 };
465 wifi_error status = global_func_table_.wifi_get_firmware_memory_dump(
466 getIfaceHandle(iface_name), {onSyncFirmwareMemoryDump});
467 on_firmware_memory_dump_internal_callback = nullptr;
468 return {status, std::move(firmware_dump)};
469 }
471 std::pair<wifi_error, uint32_t> WifiLegacyHal::getSupportedFeatureSet(
472 const std::string& iface_name) {
473 feature_set set;
474 static_assert(sizeof(set) == sizeof(uint32_t),
475 "Some feature_flags can not be represented in output");
476 wifi_error status = global_func_table_.wifi_get_supported_feature_set(
477 getIfaceHandle(iface_name), &set);
478 return {status, static_cast<uint32_t>(set)};
479 }
481 std::pair<wifi_error, PacketFilterCapabilities>
482 WifiLegacyHal::getPacketFilterCapabilities(const std::string& iface_name) {
483 PacketFilterCapabilities caps;
484 wifi_error status = global_func_table_.wifi_get_packet_filter_capabilities(
485 getIfaceHandle(iface_name), &caps.version, &caps.max_len);
486 return {status, caps};
487 }
489 wifi_error WifiLegacyHal::setPacketFilter(const std::string& iface_name,
490 const std::vector<uint8_t>& program) {
491 return global_func_table_.wifi_set_packet_filter(
492 getIfaceHandle(iface_name), program.data(), program.size());
493 }
495 std::pair<wifi_error, std::vector<uint8_t>>
496 WifiLegacyHal::readApfPacketFilterData(const std::string& iface_name) {
497 if (global_func_table_.wifi_read_packet_filter == nullptr) {
498 return {WIFI_ERROR_NOT_SUPPORTED, {}};
499 }
501 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 }
508 // Size the buffer to read the entire program & work memory.
509 std::vector<uint8_t> buffer(caps.max_len);
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 }
517 std::pair<wifi_error, wifi_gscan_capabilities>
518 WifiLegacyHal::getGscanCapabilities(const std::string& iface_name) {
519 wifi_gscan_capabilities caps;
520 wifi_error status = global_func_table_.wifi_get_gscan_capabilities(
521 getIfaceHandle(iface_name), &caps);
522 return {status, caps};
523 }
525 wifi_error WifiLegacyHal::startGscan(
526 const std::string& iface_name, wifi_request_id id,
527 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) {
531 // 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;
535 }
537 // 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 };
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 };
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;
584 }
586 wifi_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;
604 }
606 std::pair<wifi_error, std::vector<uint32_t>>
607 WifiLegacyHal::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)};
621 }
623 wifi_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);
627 }
629 wifi_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);
636 }
638 wifi_error WifiLegacyHal::disableLinkLayerStats(const std::string& iface_name) {
639 // 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);
644 }
646 std::pair<wifi_error, LinkLayerStats> WifiLegacyHal::getLinkLayerStats(
647 const std::string& iface_name) {
648 LinkLayerStats link_stats{};
649 LinkLayerStats* link_stats_ptr = &link_stats;
651 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 };
682 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};
686 }
688 wifi_error WifiLegacyHal::startRssiMonitoring(
689 const std::string& iface_name, wifi_request_id id, int8_t max_rssi,
690 int8_t min_rssi,
691 const on_rssi_threshold_breached_callback&
692 on_threshold_breached_user_callback) {
693 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;
715 }
717 wifi_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;
730 }
732 std::pair<wifi_error, wifi_roaming_capabilities>
733 WifiLegacyHal::getRoamingCapabilities(const std::string& iface_name) {
734 wifi_roaming_capabilities caps;
735 wifi_error status = global_func_table_.wifi_get_roaming_capabilities(
736 getIfaceHandle(iface_name), &caps);
737 return {status, caps};
738 }
740 wifi_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);
745 }
747 wifi_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);
751 }
753 wifi_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);
757 }
759 wifi_error WifiLegacyHal::startSendingOffloadedPacket(
760 const std::string& iface_name, uint32_t cmd_id,
761 const std::vector<uint8_t>& ip_packet_data,
762 const std::array<uint8_t, 6>& src_address,
763 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);
773 }
775 wifi_error WifiLegacyHal::stopSendingOffloadedPacket(
776 const std::string& iface_name, uint32_t cmd_id) {
777 return global_func_table_.wifi_stop_sending_offloaded_packet(
778 cmd_id, getIfaceHandle(iface_name));
779 }
781 wifi_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());
786 }
788 wifi_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);
792 }
794 wifi_error WifiLegacyHal::resetTxPowerScenario(const std::string& iface_name) {
795 return global_func_table_.wifi_reset_tx_power_scenario(
796 getIfaceHandle(iface_name));
797 }
799 std::pair<wifi_error, uint32_t> WifiLegacyHal::getLoggerSupportedFeatureSet(
800 const std::string& iface_name) {
801 uint32_t supported_feature_flags;
802 wifi_error status =
803 global_func_table_.wifi_get_logger_supported_feature_set(
804 getIfaceHandle(iface_name), &supported_feature_flags);
805 return {status, supported_feature_flags};
806 }
808 wifi_error WifiLegacyHal::startPktFateMonitoring(
809 const std::string& iface_name) {
810 return global_func_table_.wifi_start_pkt_fate_monitoring(
811 getIfaceHandle(iface_name));
812 }
814 std::pair<wifi_error, std::vector<wifi_tx_report>> WifiLegacyHal::getTxPktFates(
815 const std::string& iface_name) {
816 std::vector<wifi_tx_report> tx_pkt_fates;
817 tx_pkt_fates.resize(MAX_FATE_LOG_LEN);
818 size_t num_fates = 0;
819 wifi_error status = global_func_table_.wifi_get_tx_pkt_fates(
820 getIfaceHandle(iface_name), tx_pkt_fates.data(), tx_pkt_fates.size(),
821 &num_fates);
822 CHECK(num_fates <= MAX_FATE_LOG_LEN);
823 tx_pkt_fates.resize(num_fates);
824 return {status, std::move(tx_pkt_fates)};
825 }
827 std::pair<wifi_error, std::vector<wifi_rx_report>> WifiLegacyHal::getRxPktFates(
828 const std::string& iface_name) {
829 std::vector<wifi_rx_report> rx_pkt_fates;
830 rx_pkt_fates.resize(MAX_FATE_LOG_LEN);
831 size_t num_fates = 0;
832 wifi_error status = global_func_table_.wifi_get_rx_pkt_fates(
833 getIfaceHandle(iface_name), rx_pkt_fates.data(), rx_pkt_fates.size(),
834 &num_fates);
835 CHECK(num_fates <= MAX_FATE_LOG_LEN);
836 rx_pkt_fates.resize(num_fates);
837 return {status, std::move(rx_pkt_fates)};
838 }
840 std::pair<wifi_error, WakeReasonStats> WifiLegacyHal::getWakeReasonStats(
841 const std::string& iface_name) {
842 WakeReasonStats stats;
843 stats.cmd_event_wake_cnt.resize(kMaxWakeReasonStatsArraySize);
844 stats.driver_fw_local_wake_cnt.resize(kMaxWakeReasonStatsArraySize);
846 // This legacy struct needs separate memory to store the variable sized wake
847 // reason types.
848 stats.wake_reason_cnt.cmd_event_wake_cnt =
849 reinterpret_cast<int32_t*>(stats.cmd_event_wake_cnt.data());
850 stats.wake_reason_cnt.cmd_event_wake_cnt_sz =
851 stats.cmd_event_wake_cnt.size();
852 stats.wake_reason_cnt.cmd_event_wake_cnt_used = 0;
853 stats.wake_reason_cnt.driver_fw_local_wake_cnt =
854 reinterpret_cast<int32_t*>(stats.driver_fw_local_wake_cnt.data());
855 stats.wake_reason_cnt.driver_fw_local_wake_cnt_sz =
856 stats.driver_fw_local_wake_cnt.size();
857 stats.wake_reason_cnt.driver_fw_local_wake_cnt_used = 0;
859 wifi_error status = global_func_table_.wifi_get_wake_reason_stats(
860 getIfaceHandle(iface_name), &stats.wake_reason_cnt);
862 CHECK(
863 stats.wake_reason_cnt.cmd_event_wake_cnt_used >= 0 &&
864 static_cast<uint32_t>(stats.wake_reason_cnt.cmd_event_wake_cnt_used) <=
865 kMaxWakeReasonStatsArraySize);
866 stats.cmd_event_wake_cnt.resize(
867 stats.wake_reason_cnt.cmd_event_wake_cnt_used);
868 stats.wake_reason_cnt.cmd_event_wake_cnt = nullptr;
870 CHECK(stats.wake_reason_cnt.driver_fw_local_wake_cnt_used >= 0 &&
871 static_cast<uint32_t>(
872 stats.wake_reason_cnt.driver_fw_local_wake_cnt_used) <=
873 kMaxWakeReasonStatsArraySize);
874 stats.driver_fw_local_wake_cnt.resize(
875 stats.wake_reason_cnt.driver_fw_local_wake_cnt_used);
876 stats.wake_reason_cnt.driver_fw_local_wake_cnt = nullptr;
878 return {status, stats};
879 }
881 wifi_error WifiLegacyHal::registerRingBufferCallbackHandler(
882 const std::string& iface_name,
883 const on_ring_buffer_data_callback& on_user_data_callback) {
884 if (on_ring_buffer_data_internal_callback) {
885 return WIFI_ERROR_NOT_AVAILABLE;
886 }
887 on_ring_buffer_data_internal_callback =
888 [on_user_data_callback](char* ring_name, char* buffer, int buffer_size,
889 wifi_ring_buffer_status* status) {
890 if (status && buffer) {
891 std::vector<uint8_t> buffer_vector(
892 reinterpret_cast<uint8_t*>(buffer),
893 reinterpret_cast<uint8_t*>(buffer) + buffer_size);
894 on_user_data_callback(ring_name, buffer_vector, *status);
895 }
896 };
897 wifi_error status = global_func_table_.wifi_set_log_handler(
898 0, getIfaceHandle(iface_name), {onAsyncRingBufferData});
899 if (status != WIFI_SUCCESS) {
900 on_ring_buffer_data_internal_callback = nullptr;
901 }
902 return status;
903 }
905 wifi_error WifiLegacyHal::deregisterRingBufferCallbackHandler(
906 const std::string& iface_name) {
907 if (!on_ring_buffer_data_internal_callback) {
908 return WIFI_ERROR_NOT_AVAILABLE;
909 }
910 on_ring_buffer_data_internal_callback = nullptr;
911 return global_func_table_.wifi_reset_log_handler(
912 0, getIfaceHandle(iface_name));
913 }
915 std::pair<wifi_error, std::vector<wifi_ring_buffer_status>>
916 WifiLegacyHal::getRingBuffersStatus(const std::string& iface_name) {
917 std::vector<wifi_ring_buffer_status> ring_buffers_status;
918 ring_buffers_status.resize(kMaxRingBuffers);
919 uint32_t num_rings = kMaxRingBuffers;
920 wifi_error status = global_func_table_.wifi_get_ring_buffers_status(
921 getIfaceHandle(iface_name), &num_rings, ring_buffers_status.data());
922 CHECK(num_rings <= kMaxRingBuffers);
923 ring_buffers_status.resize(num_rings);
924 return {status, std::move(ring_buffers_status)};
925 }
927 wifi_error WifiLegacyHal::startRingBufferLogging(const std::string& iface_name,
928 const std::string& ring_name,
929 uint32_t verbose_level,
930 uint32_t max_interval_sec,
931 uint32_t min_data_size) {
932 return global_func_table_.wifi_start_logging(
933 getIfaceHandle(iface_name), verbose_level, 0, max_interval_sec,
934 min_data_size, makeCharVec(ring_name).data());
935 }
937 wifi_error WifiLegacyHal::getRingBufferData(const std::string& iface_name,
938 const std::string& ring_name) {
939 return global_func_table_.wifi_get_ring_data(getIfaceHandle(iface_name),
940 makeCharVec(ring_name).data());
941 }
943 wifi_error WifiLegacyHal::registerErrorAlertCallbackHandler(
944 const std::string& iface_name,
945 const on_error_alert_callback& on_user_alert_callback) {
946 if (on_error_alert_internal_callback) {
947 return WIFI_ERROR_NOT_AVAILABLE;
948 }
949 on_error_alert_internal_callback = [on_user_alert_callback](
950 wifi_request_id id, char* buffer,
951 int buffer_size, int err_code) {
952 if (buffer) {
953 CHECK(id == 0);
954 on_user_alert_callback(
955 err_code,
956 std::vector<uint8_t>(
957 reinterpret_cast<uint8_t*>(buffer),
958 reinterpret_cast<uint8_t*>(buffer) + buffer_size));
959 }
960 };
961 wifi_error status = global_func_table_.wifi_set_alert_handler(
962 0, getIfaceHandle(iface_name), {onAsyncErrorAlert});
963 if (status != WIFI_SUCCESS) {
964 on_error_alert_internal_callback = nullptr;
965 }
966 return status;
967 }
969 wifi_error WifiLegacyHal::deregisterErrorAlertCallbackHandler(
970 const std::string& iface_name) {
971 if (!on_error_alert_internal_callback) {
972 return WIFI_ERROR_NOT_AVAILABLE;
973 }
974 on_error_alert_internal_callback = nullptr;
975 return global_func_table_.wifi_reset_alert_handler(
976 0, getIfaceHandle(iface_name));
977 }
979 wifi_error WifiLegacyHal::registerRadioModeChangeCallbackHandler(
980 const std::string& iface_name,
981 const on_radio_mode_change_callback& on_user_change_callback) {
982 if (on_radio_mode_change_internal_callback) {
983 return WIFI_ERROR_NOT_AVAILABLE;
984 }
985 on_radio_mode_change_internal_callback = [on_user_change_callback](
986 wifi_request_id /* id */,
987 uint32_t num_macs,
988 wifi_mac_info* mac_infos_arr) {
989 if (num_macs > 0 && mac_infos_arr) {
990 std::vector<WifiMacInfo> mac_infos_vec;
991 for (uint32_t i = 0; i < num_macs; i++) {
992 WifiMacInfo mac_info;
993 mac_info.wlan_mac_id = mac_infos_arr[i].wlan_mac_id;
994 mac_info.mac_band = mac_infos_arr[i].mac_band;
995 for (int32_t j = 0; j < mac_infos_arr[i].num_iface; j++) {
996 WifiIfaceInfo iface_info;
997 iface_info.name = mac_infos_arr[i].iface_info[j].iface_name;
998 iface_info.channel = mac_infos_arr[i].iface_info[j].channel;
999 mac_info.iface_infos.push_back(iface_info);
1000 }
1001 mac_infos_vec.push_back(mac_info);
1002 }
1003 on_user_change_callback(mac_infos_vec);
1004 }
1005 };
1006 wifi_error status = global_func_table_.wifi_set_radio_mode_change_handler(
1007 0, getIfaceHandle(iface_name), {onAsyncRadioModeChange});
1008 if (status != WIFI_SUCCESS) {
1009 on_radio_mode_change_internal_callback = nullptr;
1010 }
1011 return status;
1012 }
1014 wifi_error WifiLegacyHal::startRttRangeRequest(
1015 const std::string& iface_name, wifi_request_id id,
1016 const std::vector<wifi_rtt_config>& rtt_configs,
1017 const on_rtt_results_callback& on_results_user_callback) {
1018 if (on_rtt_results_internal_callback) {
1019 return WIFI_ERROR_NOT_AVAILABLE;
1020 }
1022 on_rtt_results_internal_callback =
1023 [on_results_user_callback](wifi_request_id id, unsigned num_results,
1024 wifi_rtt_result* rtt_results[]) {
1025 if (num_results > 0 && !rtt_results) {
1026 LOG(ERROR) << "Unexpected nullptr in RTT results";
1027 return;
1028 }
1029 std::vector<const wifi_rtt_result*> rtt_results_vec;
1030 std::copy_if(rtt_results, rtt_results + num_results,
1031 back_inserter(rtt_results_vec),
1032 [](wifi_rtt_result* rtt_result) {
1033 return rtt_result != nullptr;
1034 });
1035 on_results_user_callback(id, rtt_results_vec);
1036 };
1038 std::vector<wifi_rtt_config> rtt_configs_internal(rtt_configs);
1039 wifi_error status = global_func_table_.wifi_rtt_range_request(
1040 id, getIfaceHandle(iface_name), rtt_configs.size(),
1041 rtt_configs_internal.data(), {onAsyncRttResults});
1042 if (status != WIFI_SUCCESS) {
1043 on_rtt_results_internal_callback = nullptr;
1044 }
1045 return status;
1046 }
1048 wifi_error WifiLegacyHal::cancelRttRangeRequest(
1049 const std::string& iface_name, wifi_request_id id,
1050 const std::vector<std::array<uint8_t, 6>>& mac_addrs) {
1051 if (!on_rtt_results_internal_callback) {
1052 return WIFI_ERROR_NOT_AVAILABLE;
1053 }
1054 static_assert(sizeof(mac_addr) == sizeof(std::array<uint8_t, 6>),
1055 "MAC address size mismatch");
1056 // TODO: How do we handle partial cancels (i.e only a subset of enabled mac
1057 // addressed are cancelled).
1058 std::vector<std::array<uint8_t, 6>> mac_addrs_internal(mac_addrs);
1059 wifi_error status = global_func_table_.wifi_rtt_range_cancel(
1060 id, getIfaceHandle(iface_name), mac_addrs.size(),
1061 reinterpret_cast<mac_addr*>(mac_addrs_internal.data()));
1062 // If the request Id is wrong, don't stop the ongoing range request. Any
1063 // other error should be treated as the end of rtt ranging.
1064 if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
1065 on_rtt_results_internal_callback = nullptr;
1066 }
1067 return status;
1068 }
1070 std::pair<wifi_error, wifi_rtt_capabilities> WifiLegacyHal::getRttCapabilities(
1071 const std::string& iface_name) {
1072 wifi_rtt_capabilities rtt_caps;
1073 wifi_error status = global_func_table_.wifi_get_rtt_capabilities(
1074 getIfaceHandle(iface_name), &rtt_caps);
1075 return {status, rtt_caps};
1076 }
1078 std::pair<wifi_error, wifi_rtt_responder> WifiLegacyHal::getRttResponderInfo(
1079 const std::string& iface_name) {
1080 wifi_rtt_responder rtt_responder;
1081 wifi_error status = global_func_table_.wifi_rtt_get_responder_info(
1082 getIfaceHandle(iface_name), &rtt_responder);
1083 return {status, rtt_responder};
1084 }
1086 wifi_error WifiLegacyHal::enableRttResponder(
1087 const std::string& iface_name, wifi_request_id id,
1088 const wifi_channel_info& channel_hint, uint32_t max_duration_secs,
1089 const wifi_rtt_responder& info) {
1090 wifi_rtt_responder info_internal(info);
1091 return global_func_table_.wifi_enable_responder(
1092 id, getIfaceHandle(iface_name), channel_hint, max_duration_secs,
1093 &info_internal);
1094 }
1096 wifi_error WifiLegacyHal::disableRttResponder(const std::string& iface_name,
1097 wifi_request_id id) {
1098 return global_func_table_.wifi_disable_responder(
1099 id, getIfaceHandle(iface_name));
1100 }
1102 wifi_error WifiLegacyHal::setRttLci(const std::string& iface_name,
1103 wifi_request_id id,
1104 const wifi_lci_information& info) {
1105 wifi_lci_information info_internal(info);
1106 return global_func_table_.wifi_set_lci(id, getIfaceHandle(iface_name),
1107 &info_internal);
1108 }
1110 wifi_error WifiLegacyHal::setRttLcr(const std::string& iface_name,
1111 wifi_request_id id,
1112 const wifi_lcr_information& info) {
1113 wifi_lcr_information info_internal(info);
1114 return global_func_table_.wifi_set_lcr(id, getIfaceHandle(iface_name),
1115 &info_internal);
1116 }
1118 wifi_error WifiLegacyHal::nanRegisterCallbackHandlers(
1119 const std::string& iface_name, const NanCallbackHandlers& user_callbacks) {
1120 on_nan_notify_response_user_callback = user_callbacks.on_notify_response;
1121 on_nan_event_publish_terminated_user_callback =
1122 user_callbacks.on_event_publish_terminated;
1123 on_nan_event_match_user_callback = user_callbacks.on_event_match;
1124 on_nan_event_match_expired_user_callback =
1125 user_callbacks.on_event_match_expired;
1126 on_nan_event_subscribe_terminated_user_callback =
1127 user_callbacks.on_event_subscribe_terminated;
1128 on_nan_event_followup_user_callback = user_callbacks.on_event_followup;
1129 on_nan_event_disc_eng_event_user_callback =
1130 user_callbacks.on_event_disc_eng_event;
1131 on_nan_event_disabled_user_callback = user_callbacks.on_event_disabled;
1132 on_nan_event_tca_user_callback = user_callbacks.on_event_tca;
1133 on_nan_event_beacon_sdf_payload_user_callback =
1134 user_callbacks.on_event_beacon_sdf_payload;
1135 on_nan_event_data_path_request_user_callback =
1136 user_callbacks.on_event_data_path_request;
1137 on_nan_event_data_path_confirm_user_callback =
1138 user_callbacks.on_event_data_path_confirm;
1139 on_nan_event_data_path_end_user_callback =
1140 user_callbacks.on_event_data_path_end;
1141 on_nan_event_transmit_follow_up_user_callback =
1142 user_callbacks.on_event_transmit_follow_up;
1143 on_nan_event_range_request_user_callback =
1144 user_callbacks.on_event_range_request;
1145 on_nan_event_range_report_user_callback =
1146 user_callbacks.on_event_range_report;
1147 on_nan_event_schedule_update_user_callback =
1148 user_callbacks.on_event_schedule_update;
1150 return global_func_table_.wifi_nan_register_handler(
1151 getIfaceHandle(iface_name),
1152 {onAysncNanNotifyResponse, onAysncNanEventPublishReplied,
1153 onAysncNanEventPublishTerminated, onAysncNanEventMatch,
1154 onAysncNanEventMatchExpired, onAysncNanEventSubscribeTerminated,
1155 onAysncNanEventFollowup, onAysncNanEventDiscEngEvent,
1156 onAysncNanEventDisabled, onAysncNanEventTca,
1157 onAysncNanEventBeaconSdfPayload, onAysncNanEventDataPathRequest,
1158 onAysncNanEventDataPathConfirm, onAysncNanEventDataPathEnd,
1159 onAysncNanEventTransmitFollowUp, onAysncNanEventRangeRequest,
1160 onAysncNanEventRangeReport, onAsyncNanEventScheduleUpdate});
1161 }
1163 wifi_error WifiLegacyHal::nanEnableRequest(const std::string& iface_name,
1164 transaction_id id,
1165 const NanEnableRequest& msg) {
1166 NanEnableRequest msg_internal(msg);
1167 return global_func_table_.wifi_nan_enable_request(
1168 id, getIfaceHandle(iface_name), &msg_internal);
1169 }
1171 wifi_error WifiLegacyHal::nanDisableRequest(const std::string& iface_name,
1172 transaction_id id) {
1173 return global_func_table_.wifi_nan_disable_request(
1174 id, getIfaceHandle(iface_name));
1175 }
1177 wifi_error WifiLegacyHal::nanPublishRequest(const std::string& iface_name,
1178 transaction_id id,
1179 const NanPublishRequest& msg) {
1180 NanPublishRequest msg_internal(msg);
1181 return global_func_table_.wifi_nan_publish_request(
1182 id, getIfaceHandle(iface_name), &msg_internal);
1183 }
1185 wifi_error WifiLegacyHal::nanPublishCancelRequest(
1186 const std::string& iface_name, transaction_id id,
1187 const NanPublishCancelRequest& msg) {
1188 NanPublishCancelRequest msg_internal(msg);
1189 return global_func_table_.wifi_nan_publish_cancel_request(
1190 id, getIfaceHandle(iface_name), &msg_internal);
1191 }
1193 wifi_error WifiLegacyHal::nanSubscribeRequest(const std::string& iface_name,
1194 transaction_id id,
1195 const NanSubscribeRequest& msg) {
1196 NanSubscribeRequest msg_internal(msg);
1197 return global_func_table_.wifi_nan_subscribe_request(
1198 id, getIfaceHandle(iface_name), &msg_internal);
1199 }
1201 wifi_error WifiLegacyHal::nanSubscribeCancelRequest(
1202 const std::string& iface_name, transaction_id id,
1203 const NanSubscribeCancelRequest& msg) {
1204 NanSubscribeCancelRequest msg_internal(msg);
1205 return global_func_table_.wifi_nan_subscribe_cancel_request(
1206 id, getIfaceHandle(iface_name), &msg_internal);
1207 }
1209 wifi_error WifiLegacyHal::nanTransmitFollowupRequest(
1210 const std::string& iface_name, transaction_id id,
1211 const NanTransmitFollowupRequest& msg) {
1212 NanTransmitFollowupRequest msg_internal(msg);
1213 return global_func_table_.wifi_nan_transmit_followup_request(
1214 id, getIfaceHandle(iface_name), &msg_internal);
1215 }
1217 wifi_error WifiLegacyHal::nanStatsRequest(const std::string& iface_name,
1218 transaction_id id,
1219 const NanStatsRequest& msg) {
1220 NanStatsRequest msg_internal(msg);
1221 return global_func_table_.wifi_nan_stats_request(
1222 id, getIfaceHandle(iface_name), &msg_internal);
1223 }
1225 wifi_error WifiLegacyHal::nanConfigRequest(const std::string& iface_name,
1226 transaction_id id,
1227 const NanConfigRequest& msg) {
1228 NanConfigRequest msg_internal(msg);
1229 return global_func_table_.wifi_nan_config_request(
1230 id, getIfaceHandle(iface_name), &msg_internal);
1231 }
1233 wifi_error WifiLegacyHal::nanTcaRequest(const std::string& iface_name,
1234 transaction_id id,
1235 const NanTCARequest& msg) {
1236 NanTCARequest msg_internal(msg);
1237 return global_func_table_.wifi_nan_tca_request(
1238 id, getIfaceHandle(iface_name), &msg_internal);
1239 }
1241 wifi_error WifiLegacyHal::nanBeaconSdfPayloadRequest(
1242 const std::string& iface_name, transaction_id id,
1243 const NanBeaconSdfPayloadRequest& msg) {
1244 NanBeaconSdfPayloadRequest msg_internal(msg);
1245 return global_func_table_.wifi_nan_beacon_sdf_payload_request(
1246 id, getIfaceHandle(iface_name), &msg_internal);
1247 }
1249 std::pair<wifi_error, NanVersion> WifiLegacyHal::nanGetVersion() {
1250 NanVersion version;
1251 wifi_error status =
1252 global_func_table_.wifi_nan_get_version(global_handle_, &version);
1253 return {status, version};
1254 }
1256 wifi_error WifiLegacyHal::nanGetCapabilities(const std::string& iface_name,
1257 transaction_id id) {
1258 return global_func_table_.wifi_nan_get_capabilities(
1259 id, getIfaceHandle(iface_name));
1260 }
1262 wifi_error WifiLegacyHal::nanDataInterfaceCreate(
1263 const std::string& iface_name, transaction_id id,
1264 const std::string& data_iface_name) {
1265 return global_func_table_.wifi_nan_data_interface_create(
1266 id, getIfaceHandle(iface_name), makeCharVec(data_iface_name).data());
1267 }
1269 wifi_error WifiLegacyHal::nanDataInterfaceDelete(
1270 const std::string& iface_name, transaction_id id,
1271 const std::string& data_iface_name) {
1272 return global_func_table_.wifi_nan_data_interface_delete(
1273 id, getIfaceHandle(iface_name), makeCharVec(data_iface_name).data());
1274 }
1276 wifi_error WifiLegacyHal::nanDataRequestInitiator(
1277 const std::string& iface_name, transaction_id id,
1278 const NanDataPathInitiatorRequest& msg) {
1279 NanDataPathInitiatorRequest msg_internal(msg);
1280 return global_func_table_.wifi_nan_data_request_initiator(
1281 id, getIfaceHandle(iface_name), &msg_internal);
1282 }
1284 wifi_error WifiLegacyHal::nanDataIndicationResponse(
1285 const std::string& iface_name, transaction_id id,
1286 const NanDataPathIndicationResponse& msg) {
1287 NanDataPathIndicationResponse msg_internal(msg);
1288 return global_func_table_.wifi_nan_data_indication_response(
1289 id, getIfaceHandle(iface_name), &msg_internal);
1290 }
1292 typedef struct {
1293 u8 num_ndp_instances;
1294 NanDataPathId ndp_instance_id;
1295 } NanDataPathEndSingleNdpIdRequest;
1297 wifi_error WifiLegacyHal::nanDataEnd(const std::string& iface_name,
1298 transaction_id id,
1299 uint32_t ndpInstanceId) {
1300 NanDataPathEndSingleNdpIdRequest msg;
1301 msg.num_ndp_instances = 1;
1302 msg.ndp_instance_id = ndpInstanceId;
1303 wifi_error status = global_func_table_.wifi_nan_data_end(
1304 id, getIfaceHandle(iface_name), (NanDataPathEndRequest*)&msg);
1305 return status;
1306 }
1308 wifi_error WifiLegacyHal::setCountryCode(const std::string& iface_name,
1309 std::array<int8_t, 2> code) {
1310 std::string code_str(code.data(), code.data() + code.size());
1311 return global_func_table_.wifi_set_country_code(getIfaceHandle(iface_name),
1312 code_str.c_str());
1313 }
1315 wifi_error WifiLegacyHal::retrieveIfaceHandles() {
1316 wifi_interface_handle* iface_handles = nullptr;
1317 int num_iface_handles = 0;
1318 wifi_error status = global_func_table_.wifi_get_ifaces(
1319 global_handle_, &num_iface_handles, &iface_handles);
1320 if (status != WIFI_SUCCESS) {
1321 LOG(ERROR) << "Failed to enumerate interface handles";
1322 return status;
1323 }
1324 for (int i = 0; i < num_iface_handles; ++i) {
1325 std::array<char, IFNAMSIZ> iface_name_arr = {};
1326 status = global_func_table_.wifi_get_iface_name(
1327 iface_handles[i], iface_name_arr.data(), iface_name_arr.size());
1328 if (status != WIFI_SUCCESS) {
1329 LOG(WARNING) << "Failed to get interface handle name";
1330 continue;
1331 }
1332 // Assuming the interface name is null terminated since the legacy HAL
1333 // API does not return a size.
1334 std::string iface_name(iface_name_arr.data());
1335 LOG(INFO) << "Adding interface handle for " << iface_name;
1336 iface_name_to_handle_[iface_name] = iface_handles[i];
1337 }
1338 return WIFI_SUCCESS;
1339 }
1341 wifi_interface_handle WifiLegacyHal::getIfaceHandle(
1342 const std::string& iface_name) {
1343 const auto iface_handle_iter = iface_name_to_handle_.find(iface_name);
1344 if (iface_handle_iter == iface_name_to_handle_.end()) {
1345 LOG(ERROR) << "Unknown iface name: " << iface_name;
1346 return nullptr;
1347 }
1348 return iface_handle_iter->second;
1349 }
1351 void WifiLegacyHal::runEventLoop() {
1352 LOG(DEBUG) << "Starting legacy HAL event loop";
1353 global_func_table_.wifi_event_loop(global_handle_);
1354 const auto lock = hidl_sync_util::acquireGlobalLock();
1355 if (!awaiting_event_loop_termination_) {
1356 LOG(FATAL)
1357 << "Legacy HAL event loop terminated, but HAL was not stopping";
1358 }
1359 LOG(DEBUG) << "Legacy HAL event loop terminated";
1360 awaiting_event_loop_termination_ = false;
1361 stop_wait_cv_.notify_one();
1362 }
1364 std::pair<wifi_error, std::vector<wifi_cached_scan_results>>
1365 WifiLegacyHal::getGscanCachedResults(const std::string& iface_name) {
1366 std::vector<wifi_cached_scan_results> cached_scan_results;
1367 cached_scan_results.resize(kMaxCachedGscanResults);
1368 int32_t num_results = 0;
1369 wifi_error status = global_func_table_.wifi_get_cached_gscan_results(
1370 getIfaceHandle(iface_name), true /* always flush */,
1371 cached_scan_results.size(), cached_scan_results.data(), &num_results);
1372 CHECK(num_results >= 0 &&
1373 static_cast<uint32_t>(num_results) <= kMaxCachedGscanResults);
1374 cached_scan_results.resize(num_results);
1375 // Check for invalid IE lengths in these cached scan results and correct it.
1376 for (auto& cached_scan_result : cached_scan_results) {
1377 int num_scan_results = cached_scan_result.num_results;
1378 for (int i = 0; i < num_scan_results; i++) {
1379 auto& scan_result = cached_scan_result.results[i];
1380 if (scan_result.ie_length > 0) {
1381 LOG(DEBUG) << "Cached scan result has non-zero IE length "
1382 << scan_result.ie_length;
1383 scan_result.ie_length = 0;
1384 }
1385 }
1386 }
1387 return {status, std::move(cached_scan_results)};
1388 }
1390 void WifiLegacyHal::invalidate() {
1391 global_handle_ = nullptr;
1392 iface_name_to_handle_.clear();
1393 on_driver_memory_dump_internal_callback = nullptr;
1394 on_firmware_memory_dump_internal_callback = nullptr;
1395 on_gscan_event_internal_callback = nullptr;
1396 on_gscan_full_result_internal_callback = nullptr;
1397 on_link_layer_stats_result_internal_callback = nullptr;
1398 on_rssi_threshold_breached_internal_callback = nullptr;
1399 on_ring_buffer_data_internal_callback = nullptr;
1400 on_error_alert_internal_callback = nullptr;
1401 on_radio_mode_change_internal_callback = nullptr;
1402 on_rtt_results_internal_callback = nullptr;
1403 on_nan_notify_response_user_callback = nullptr;
1404 on_nan_event_publish_terminated_user_callback = nullptr;
1405 on_nan_event_match_user_callback = nullptr;
1406 on_nan_event_match_expired_user_callback = nullptr;
1407 on_nan_event_subscribe_terminated_user_callback = nullptr;
1408 on_nan_event_followup_user_callback = nullptr;
1409 on_nan_event_disc_eng_event_user_callback = nullptr;
1410 on_nan_event_disabled_user_callback = nullptr;
1411 on_nan_event_tca_user_callback = nullptr;
1412 on_nan_event_beacon_sdf_payload_user_callback = nullptr;
1413 on_nan_event_data_path_request_user_callback = nullptr;
1414 on_nan_event_data_path_confirm_user_callback = nullptr;
1415 on_nan_event_data_path_end_user_callback = nullptr;
1416 on_nan_event_transmit_follow_up_user_callback = nullptr;
1417 on_nan_event_range_request_user_callback = nullptr;
1418 on_nan_event_range_report_user_callback = nullptr;
1419 on_nan_event_schedule_update_user_callback = nullptr;
1420 }
1422 } // namespace legacy_hal
1423 } // namespace implementation
1424 } // namespace V1_2
1425 } // namespace wifi
1426 } // namespace hardware
1427 } // namespace android