sandy
/
PL286
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
0 Tags
18 GiB
Tree: 99da0f2c72
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '99da0f2c72'
${ noResults }
PL286/hardware/interfaces/wifi/1.1/default/wifi_legacy_hal.cpp

1345 lines
51 KiB
Raw Blame History

/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <array>
#include <chrono>
#include <android-base/logging.h>
#include <cutils/properties.h>
#include "hidl_sync_util.h"
#include "wifi_legacy_hal.h"
#include "wifi_legacy_hal_stubs.h"
namespace {
// Constants ported over from the legacy HAL calling code
// (com_android_server_wifi_WifiNative.cpp). This will all be thrown
// away when this shim layer is replaced by the real vendor
// implementation.
static constexpr uint32_t kMaxVersionStringLength = 256;
static constexpr uint32_t kMaxCachedGscanResults = 64;
static constexpr uint32_t kMaxGscanFrequenciesForBand = 64;
static constexpr uint32_t kLinkLayerStatsDataMpduSizeThreshold = 128;
static constexpr uint32_t kMaxWakeReasonStatsArraySize = 32;
static constexpr uint32_t kMaxRingBuffers = 10;
static constexpr uint32_t kMaxStopCompleteWaitMs = 100;
// Helper function to create a non-const char* for legacy Hal API's.
std::vector<char> makeCharVec(const std::string& str) {
std::vector<char> vec(str.size() + 1);
vec.assign(str.begin(), str.end());
vec.push_back('\0');
return vec;
}
} // namespace
namespace android {
namespace hardware {
namespace wifi {
namespace V1_1 {
namespace implementation {
namespace legacy_hal {
// Legacy HAL functions accept "C" style function pointers, so use global
// functions to pass to the legacy HAL function and store the corresponding
// std::function methods to be invoked.
//
// Callback to be invoked once |stop| is complete
std::function<void(wifi_handle handle)> on_stop_complete_internal_callback;
void onAsyncStopComplete(wifi_handle handle) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_stop_complete_internal_callback) {
on_stop_complete_internal_callback(handle);
// Invalidate this callback since we don't want this firing again.
on_stop_complete_internal_callback = nullptr;
}
}
// Callback to be invoked for driver dump.
std::function<void(char*, int)> on_driver_memory_dump_internal_callback;
void onSyncDriverMemoryDump(char* buffer, int buffer_size) {
if (on_driver_memory_dump_internal_callback) {
on_driver_memory_dump_internal_callback(buffer, buffer_size);
}
}
// Callback to be invoked for firmware dump.
std::function<void(char*, int)> on_firmware_memory_dump_internal_callback;
void onSyncFirmwareMemoryDump(char* buffer, int buffer_size) {
if (on_firmware_memory_dump_internal_callback) {
on_firmware_memory_dump_internal_callback(buffer, buffer_size);
}
}
// Callback to be invoked for Gscan events.
std::function<void(wifi_request_id, wifi_scan_event)>
on_gscan_event_internal_callback;
void onAsyncGscanEvent(wifi_request_id id, wifi_scan_event event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_gscan_event_internal_callback) {
on_gscan_event_internal_callback(id, event);
}
}
// Callback to be invoked for Gscan full results.
std::function<void(wifi_request_id, wifi_scan_result*, uint32_t)>
on_gscan_full_result_internal_callback;
void onAsyncGscanFullResult(wifi_request_id id,
wifi_scan_result* result,
uint32_t buckets_scanned) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_gscan_full_result_internal_callback) {
on_gscan_full_result_internal_callback(id, result, buckets_scanned);
}
}
// Callback to be invoked for link layer stats results.
std::function<void((wifi_request_id, wifi_iface_stat*, int, wifi_radio_stat*))>
on_link_layer_stats_result_internal_callback;
void onSyncLinkLayerStatsResult(wifi_request_id id,
wifi_iface_stat* iface_stat,
int num_radios,
wifi_radio_stat* radio_stat) {
if (on_link_layer_stats_result_internal_callback) {
on_link_layer_stats_result_internal_callback(
id, iface_stat, num_radios, radio_stat);
}
}
// Callback to be invoked for rssi threshold breach.
std::function<void((wifi_request_id, uint8_t*, int8_t))>
on_rssi_threshold_breached_internal_callback;
void onAsyncRssiThresholdBreached(wifi_request_id id,
uint8_t* bssid,
int8_t rssi) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_rssi_threshold_breached_internal_callback) {
on_rssi_threshold_breached_internal_callback(id, bssid, rssi);
}
}
// Callback to be invoked for ring buffer data indication.
std::function<void(char*, char*, int, wifi_ring_buffer_status*)>
on_ring_buffer_data_internal_callback;
void onAsyncRingBufferData(char* ring_name,
char* buffer,
int buffer_size,
wifi_ring_buffer_status* status) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_ring_buffer_data_internal_callback) {
on_ring_buffer_data_internal_callback(
ring_name, buffer, buffer_size, status);
}
}
// Callback to be invoked for error alert indication.
std::function<void(wifi_request_id, char*, int, int)>
on_error_alert_internal_callback;
void onAsyncErrorAlert(wifi_request_id id,
char* buffer,
int buffer_size,
int err_code) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_error_alert_internal_callback) {
on_error_alert_internal_callback(id, buffer, buffer_size, err_code);
}
}
// Callback to be invoked for rtt results results.
std::function<void(
wifi_request_id, unsigned num_results, wifi_rtt_result* rtt_results[])>
on_rtt_results_internal_callback;
void onAsyncRttResults(wifi_request_id id,
unsigned num_results,
wifi_rtt_result* rtt_results[]) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_rtt_results_internal_callback) {
on_rtt_results_internal_callback(id, num_results, rtt_results);
on_rtt_results_internal_callback = nullptr;
}
}
// Callbacks for the various NAN operations.
// NOTE: These have very little conversions to perform before invoking the user
// callbacks.
// So, handle all of them here directly to avoid adding an unnecessary layer.
std::function<void(transaction_id, const NanResponseMsg&)>
on_nan_notify_response_user_callback;
void onAysncNanNotifyResponse(transaction_id id, NanResponseMsg* msg) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_notify_response_user_callback && msg) {
on_nan_notify_response_user_callback(id, *msg);
}
}
std::function<void(const NanPublishRepliedInd&)>
on_nan_event_publish_replied_user_callback;
void onAysncNanEventPublishReplied(NanPublishRepliedInd* /* event */) {
LOG(ERROR) << "onAysncNanEventPublishReplied triggered";
}
std::function<void(const NanPublishTerminatedInd&)>
on_nan_event_publish_terminated_user_callback;
void onAysncNanEventPublishTerminated(NanPublishTerminatedInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_publish_terminated_user_callback && event) {
on_nan_event_publish_terminated_user_callback(*event);
}
}
std::function<void(const NanMatchInd&)> on_nan_event_match_user_callback;
void onAysncNanEventMatch(NanMatchInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_match_user_callback && event) {
on_nan_event_match_user_callback(*event);
}
}
std::function<void(const NanMatchExpiredInd&)>
on_nan_event_match_expired_user_callback;
void onAysncNanEventMatchExpired(NanMatchExpiredInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_match_expired_user_callback && event) {
on_nan_event_match_expired_user_callback(*event);
}
}
std::function<void(const NanSubscribeTerminatedInd&)>
on_nan_event_subscribe_terminated_user_callback;
void onAysncNanEventSubscribeTerminated(NanSubscribeTerminatedInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_subscribe_terminated_user_callback && event) {
on_nan_event_subscribe_terminated_user_callback(*event);
}
}
std::function<void(const NanFollowupInd&)> on_nan_event_followup_user_callback;
void onAysncNanEventFollowup(NanFollowupInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_followup_user_callback && event) {
on_nan_event_followup_user_callback(*event);
}
}
std::function<void(const NanDiscEngEventInd&)>
on_nan_event_disc_eng_event_user_callback;
void onAysncNanEventDiscEngEvent(NanDiscEngEventInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_disc_eng_event_user_callback && event) {
on_nan_event_disc_eng_event_user_callback(*event);
}
}
std::function<void(const NanDisabledInd&)> on_nan_event_disabled_user_callback;
void onAysncNanEventDisabled(NanDisabledInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_disabled_user_callback && event) {
on_nan_event_disabled_user_callback(*event);
}
}
std::function<void(const NanTCAInd&)> on_nan_event_tca_user_callback;
void onAysncNanEventTca(NanTCAInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_tca_user_callback && event) {
on_nan_event_tca_user_callback(*event);
}
}
std::function<void(const NanBeaconSdfPayloadInd&)>
on_nan_event_beacon_sdf_payload_user_callback;
void onAysncNanEventBeaconSdfPayload(NanBeaconSdfPayloadInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_beacon_sdf_payload_user_callback && event) {
on_nan_event_beacon_sdf_payload_user_callback(*event);
}
}
std::function<void(const NanDataPathRequestInd&)>
on_nan_event_data_path_request_user_callback;
void onAysncNanEventDataPathRequest(NanDataPathRequestInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_data_path_request_user_callback && event) {
on_nan_event_data_path_request_user_callback(*event);
}
}
std::function<void(const NanDataPathConfirmInd&)>
on_nan_event_data_path_confirm_user_callback;
void onAysncNanEventDataPathConfirm(NanDataPathConfirmInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_data_path_confirm_user_callback && event) {
on_nan_event_data_path_confirm_user_callback(*event);
}
}
std::function<void(const NanDataPathEndInd&)>
on_nan_event_data_path_end_user_callback;
void onAysncNanEventDataPathEnd(NanDataPathEndInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_data_path_end_user_callback && event) {
on_nan_event_data_path_end_user_callback(*event);
}
}
std::function<void(const NanTransmitFollowupInd&)>
on_nan_event_transmit_follow_up_user_callback;
void onAysncNanEventTransmitFollowUp(NanTransmitFollowupInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_transmit_follow_up_user_callback && event) {
on_nan_event_transmit_follow_up_user_callback(*event);
}
}
std::function<void(const NanRangeRequestInd&)>
on_nan_event_range_request_user_callback;
void onAysncNanEventRangeRequest(NanRangeRequestInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_range_request_user_callback && event) {
on_nan_event_range_request_user_callback(*event);
}
}
std::function<void(const NanRangeReportInd&)>
on_nan_event_range_report_user_callback;
void onAysncNanEventRangeReport(NanRangeReportInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (on_nan_event_range_report_user_callback && event) {
on_nan_event_range_report_user_callback(*event);
}
}
// End of the free-standing "C" style callbacks.
WifiLegacyHal::WifiLegacyHal()
: global_handle_(nullptr),
wlan_interface_handle_(nullptr),
awaiting_event_loop_termination_(false),
is_started_(false) {}
wifi_error WifiLegacyHal::initialize() {
LOG(DEBUG) << "Initialize legacy HAL";
// TODO: Add back the HAL Tool if we need to. All we need from the HAL tool
// for now is this function call which we can directly call.
if (!initHalFuncTableWithStubs(&global_func_table_)) {
LOG(ERROR) << "Failed to initialize legacy hal function table with stubs";
return WIFI_ERROR_UNKNOWN;
}
wifi_error status = init_wifi_vendor_hal_func_table(&global_func_table_);
if (status != WIFI_SUCCESS) {
LOG(ERROR) << "Failed to initialize legacy hal function table";
}
return status;
}
wifi_error WifiLegacyHal::start() {
// Ensure that we're starting in a good state.
CHECK(global_func_table_.wifi_initialize && !global_handle_ &&
!wlan_interface_handle_ && !awaiting_event_loop_termination_);
if (is_started_) {
LOG(DEBUG) << "Legacy HAL already started";
return WIFI_SUCCESS;
}
LOG(DEBUG) << "Starting legacy HAL";
if (!iface_tool_.SetWifiUpState(true)) {
LOG(ERROR) << "Failed to set WiFi interface up";
return WIFI_ERROR_UNKNOWN;
}
wifi_error status = global_func_table_.wifi_initialize(&global_handle_);
if (status != WIFI_SUCCESS || !global_handle_) {
LOG(ERROR) << "Failed to retrieve global handle";
return status;
}
std::thread(&WifiLegacyHal::runEventLoop, this).detach();
status = retrieveWlanInterfaceHandle();
if (status != WIFI_SUCCESS || !wlan_interface_handle_) {
LOG(ERROR) << "Failed to retrieve wlan interface handle";
return status;
}
LOG(DEBUG) << "Legacy HAL start complete";
is_started_ = true;
return WIFI_SUCCESS;
}
wifi_error WifiLegacyHal::stop(
/* NONNULL */ std::unique_lock<std::recursive_mutex>* lock,
const std::function<void()>& on_stop_complete_user_callback) {
if (!is_started_) {
LOG(DEBUG) << "Legacy HAL already stopped";
on_stop_complete_user_callback();
return WIFI_SUCCESS;
}
LOG(DEBUG) << "Stopping legacy HAL";
on_stop_complete_internal_callback =
[on_stop_complete_user_callback, this](wifi_handle handle) {
CHECK_EQ(global_handle_, handle) << "Handle mismatch";
LOG(INFO) << "Legacy HAL stop complete callback received";
// Invalidate all the internal pointers now that the HAL is
// stopped.
invalidate();
iface_tool_.SetWifiUpState(false);
on_stop_complete_user_callback();
is_started_ = false;
};
awaiting_event_loop_termination_ = true;
global_func_table_.wifi_cleanup(global_handle_, onAsyncStopComplete);
const auto status = stop_wait_cv_.wait_for(
*lock, std::chrono::milliseconds(kMaxStopCompleteWaitMs),
[this] { return !awaiting_event_loop_termination_; });
if (!status) {
LOG(ERROR) << "Legacy HAL stop failed or timed out";
return WIFI_ERROR_UNKNOWN;
}
LOG(DEBUG) << "Legacy HAL stop complete";
return WIFI_SUCCESS;
}
std::string WifiLegacyHal::getApIfaceName() {
// Fake name. This interface does not exist in legacy HAL
// API's.
return "ap0";
}
std::string WifiLegacyHal::getNanIfaceName() {
// Fake name. This interface does not exist in legacy HAL
// API's.
return "nan0";
}
std::string WifiLegacyHal::getP2pIfaceName() {
std::array<char, PROPERTY_VALUE_MAX> buffer;
property_get("wifi.direct.interface", buffer.data(), "p2p0");
return buffer.data();
}
std::string WifiLegacyHal::getStaIfaceName() {
std::array<char, PROPERTY_VALUE_MAX> buffer;
property_get("wifi.interface", buffer.data(), "wlan0");
return buffer.data();
}
std::pair<wifi_error, std::string> WifiLegacyHal::getDriverVersion() {
std::array<char, kMaxVersionStringLength> buffer;
buffer.fill(0);
wifi_error status = global_func_table_.wifi_get_driver_version(
wlan_interface_handle_, buffer.data(), buffer.size());
return {status, buffer.data()};
}
std::pair<wifi_error, std::string> WifiLegacyHal::getFirmwareVersion() {
std::array<char, kMaxVersionStringLength> buffer;
buffer.fill(0);
wifi_error status = global_func_table_.wifi_get_firmware_version(
wlan_interface_handle_, buffer.data(), buffer.size());
return {status, buffer.data()};
}
std::pair<wifi_error, std::vector<uint8_t>>
WifiLegacyHal::requestDriverMemoryDump() {
std::vector<uint8_t> driver_dump;
on_driver_memory_dump_internal_callback = [&driver_dump](char* buffer,
int buffer_size) {
driver_dump.insert(driver_dump.end(),
reinterpret_cast<uint8_t*>(buffer),
reinterpret_cast<uint8_t*>(buffer) + buffer_size);
};
wifi_error status = global_func_table_.wifi_get_driver_memory_dump(
wlan_interface_handle_, {onSyncDriverMemoryDump});
on_driver_memory_dump_internal_callback = nullptr;
return {status, std::move(driver_dump)};
}
std::pair<wifi_error, std::vector<uint8_t>>
WifiLegacyHal::requestFirmwareMemoryDump() {
std::vector<uint8_t> firmware_dump;
on_firmware_memory_dump_internal_callback = [&firmware_dump](
char* buffer, int buffer_size) {
firmware_dump.insert(firmware_dump.end(),
reinterpret_cast<uint8_t*>(buffer),
reinterpret_cast<uint8_t*>(buffer) + buffer_size);
};
wifi_error status = global_func_table_.wifi_get_firmware_memory_dump(
wlan_interface_handle_, {onSyncFirmwareMemoryDump});
on_firmware_memory_dump_internal_callback = nullptr;
return {status, std::move(firmware_dump)};
}
std::pair<wifi_error, uint32_t> WifiLegacyHal::getSupportedFeatureSet() {
feature_set set;
static_assert(sizeof(set) == sizeof(uint32_t),
"Some features can not be represented in output");
wifi_error status = global_func_table_.wifi_get_supported_feature_set(
wlan_interface_handle_, &set);
return {status, static_cast<uint32_t>(set)};
}
std::pair<wifi_error, PacketFilterCapabilities>
WifiLegacyHal::getPacketFilterCapabilities() {
PacketFilterCapabilities caps;
wifi_error status = global_func_table_.wifi_get_packet_filter_capabilities(
wlan_interface_handle_, &caps.version, &caps.max_len);
return {status, caps};
}
wifi_error WifiLegacyHal::setPacketFilter(const std::vector<uint8_t>& program) {
return global_func_table_.wifi_set_packet_filter(
wlan_interface_handle_, program.data(), program.size());
}
std::pair<wifi_error, wifi_gscan_capabilities>
WifiLegacyHal::getGscanCapabilities() {
wifi_gscan_capabilities caps;
wifi_error status = global_func_table_.wifi_get_gscan_capabilities(
wlan_interface_handle_, &caps);
return {status, caps};
}
wifi_error WifiLegacyHal::startGscan(
wifi_request_id id,
const wifi_scan_cmd_params& params,
const std::function<void(wifi_request_id)>& on_failure_user_callback,
const on_gscan_results_callback& on_results_user_callback,
const on_gscan_full_result_callback& on_full_result_user_callback) {
// If there is already an ongoing background scan, reject new scan requests.
if (on_gscan_event_internal_callback ||
on_gscan_full_result_internal_callback) {
return WIFI_ERROR_NOT_AVAILABLE;
}
// This callback will be used to either trigger |on_results_user_callback| or
// |on_failure_user_callback|.
on_gscan_event_internal_callback =
[on_failure_user_callback, on_results_user_callback, this](
wifi_request_id id, wifi_scan_event event) {
switch (event) {
case WIFI_SCAN_RESULTS_AVAILABLE:
case WIFI_SCAN_THRESHOLD_NUM_SCANS:
case WIFI_SCAN_THRESHOLD_PERCENT: {
wifi_error status;
std::vector<wifi_cached_scan_results> cached_scan_results;
std::tie(status, cached_scan_results) = getGscanCachedResults();
if (status == WIFI_SUCCESS) {
on_results_user_callback(id, cached_scan_results);
return;
}
}
// Fall through if failed. Failure to retrieve cached scan results
// should trigger a background scan failure.
case WIFI_SCAN_FAILED:
on_failure_user_callback(id);
on_gscan_event_internal_callback = nullptr;
on_gscan_full_result_internal_callback = nullptr;
return;
}
LOG(FATAL) << "Unexpected gscan event received: " << event;
};
on_gscan_full_result_internal_callback = [on_full_result_user_callback](
wifi_request_id id, wifi_scan_result* result, uint32_t buckets_scanned) {
if (result) {
on_full_result_user_callback(id, result, buckets_scanned);
}
};
wifi_scan_result_handler handler = {onAsyncGscanFullResult,
onAsyncGscanEvent};
wifi_error status = global_func_table_.wifi_start_gscan(
id, wlan_interface_handle_, params, handler);
if (status != WIFI_SUCCESS) {
on_gscan_event_internal_callback = nullptr;
on_gscan_full_result_internal_callback = nullptr;
}
return status;
}
wifi_error WifiLegacyHal::stopGscan(wifi_request_id id) {
// If there is no an ongoing background scan, reject stop requests.
// TODO(b/32337212): This needs to be handled by the HIDL object because we
// need to return the NOT_STARTED error code.
if (!on_gscan_event_internal_callback &&
!on_gscan_full_result_internal_callback) {
return WIFI_ERROR_NOT_AVAILABLE;
}
wifi_error status =
global_func_table_.wifi_stop_gscan(id, wlan_interface_handle_);
// If the request Id is wrong, don't stop the ongoing background scan. Any
// other error should be treated as the end of background scan.
if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
on_gscan_event_internal_callback = nullptr;
on_gscan_full_result_internal_callback = nullptr;
}
return status;
}
std::pair<wifi_error, std::vector<uint32_t>>
WifiLegacyHal::getValidFrequenciesForBand(wifi_band band) {
static_assert(sizeof(uint32_t) >= sizeof(wifi_channel),
"Wifi Channel cannot be represented in output");
std::vector<uint32_t> freqs;
freqs.resize(kMaxGscanFrequenciesForBand);
int32_t num_freqs = 0;
wifi_error status = global_func_table_.wifi_get_valid_channels(
wlan_interface_handle_,
band,
freqs.size(),
reinterpret_cast<wifi_channel*>(freqs.data()),
&num_freqs);
CHECK(num_freqs >= 0 &&
static_cast<uint32_t>(num_freqs) <= kMaxGscanFrequenciesForBand);
freqs.resize(num_freqs);
return {status, std::move(freqs)};
}
wifi_error WifiLegacyHal::setDfsFlag(bool dfs_on) {
return global_func_table_.wifi_set_nodfs_flag(
wlan_interface_handle_, dfs_on ? 0 : 1);
}
wifi_error WifiLegacyHal::enableLinkLayerStats(bool debug) {
wifi_link_layer_params params;
params.mpdu_size_threshold = kLinkLayerStatsDataMpduSizeThreshold;
params.aggressive_statistics_gathering = debug;
return global_func_table_.wifi_set_link_stats(wlan_interface_handle_, params);
}
wifi_error WifiLegacyHal::disableLinkLayerStats() {
// TODO: Do we care about these responses?
uint32_t clear_mask_rsp;
uint8_t stop_rsp;
return global_func_table_.wifi_clear_link_stats(
wlan_interface_handle_, 0xFFFFFFFF, &clear_mask_rsp, 1, &stop_rsp);
}
std::pair<wifi_error, LinkLayerStats> WifiLegacyHal::getLinkLayerStats() {
LinkLayerStats link_stats{};
LinkLayerStats* link_stats_ptr = &link_stats;
on_link_layer_stats_result_internal_callback =
[&link_stats_ptr](wifi_request_id /* id */,
wifi_iface_stat* iface_stats_ptr,
int num_radios,
wifi_radio_stat* radio_stats_ptr) {
if (iface_stats_ptr != nullptr) {
link_stats_ptr->iface = *iface_stats_ptr;
link_stats_ptr->iface.num_peers = 0;
} else {
LOG(ERROR) << "Invalid iface stats in link layer stats";
}
if (num_radios <= 0 || radio_stats_ptr == nullptr) {
LOG(ERROR) << "Invalid radio stats in link layer stats";
return;
}
for (int i = 0; i < num_radios; i++) {
LinkLayerRadioStats radio;
radio.stats = radio_stats_ptr[i];
// Copy over the tx level array to the separate vector.
if (radio_stats_ptr[i].num_tx_levels > 0 &&
radio_stats_ptr[i].tx_time_per_levels != nullptr) {
radio.tx_time_per_levels.assign(
radio_stats_ptr[i].tx_time_per_levels,
radio_stats_ptr[i].tx_time_per_levels +
radio_stats_ptr[i].num_tx_levels);
}
radio.stats.num_tx_levels = 0;
radio.stats.tx_time_per_levels = nullptr;
link_stats_ptr->radios.push_back(radio);
}
};
wifi_error status = global_func_table_.wifi_get_link_stats(
0, wlan_interface_handle_, {onSyncLinkLayerStatsResult});
on_link_layer_stats_result_internal_callback = nullptr;
return {status, link_stats};
}
wifi_error WifiLegacyHal::startRssiMonitoring(
wifi_request_id id,
int8_t max_rssi,
int8_t min_rssi,
const on_rssi_threshold_breached_callback&
on_threshold_breached_user_callback) {
if (on_rssi_threshold_breached_internal_callback) {
return WIFI_ERROR_NOT_AVAILABLE;
}
on_rssi_threshold_breached_internal_callback =
[on_threshold_breached_user_callback](
wifi_request_id id, uint8_t* bssid_ptr, int8_t rssi) {
if (!bssid_ptr) {
return;
}
std::array<uint8_t, 6> bssid_arr;
// |bssid_ptr| pointer is assumed to have 6 bytes for the mac address.
std::copy(bssid_ptr, bssid_ptr + 6, std::begin(bssid_arr));
on_threshold_breached_user_callback(id, bssid_arr, rssi);
};
wifi_error status = global_func_table_.wifi_start_rssi_monitoring(
id,
wlan_interface_handle_,
max_rssi,
min_rssi,
{onAsyncRssiThresholdBreached});
if (status != WIFI_SUCCESS) {
on_rssi_threshold_breached_internal_callback = nullptr;
}
return status;
}
wifi_error WifiLegacyHal::stopRssiMonitoring(wifi_request_id id) {
if (!on_rssi_threshold_breached_internal_callback) {
return WIFI_ERROR_NOT_AVAILABLE;
}
wifi_error status =
global_func_table_.wifi_stop_rssi_monitoring(id, wlan_interface_handle_);
// If the request Id is wrong, don't stop the ongoing rssi monitoring. Any
// other error should be treated as the end of background scan.
if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
on_rssi_threshold_breached_internal_callback = nullptr;
}
return status;
}
std::pair<wifi_error, wifi_roaming_capabilities>
WifiLegacyHal::getRoamingCapabilities() {
wifi_roaming_capabilities caps;
wifi_error status = global_func_table_.wifi_get_roaming_capabilities(
wlan_interface_handle_, &caps);
return {status, caps};
}
wifi_error WifiLegacyHal::configureRoaming(const wifi_roaming_config& config) {
wifi_roaming_config config_internal = config;
return global_func_table_.wifi_configure_roaming(wlan_interface_handle_,
&config_internal);
}
wifi_error WifiLegacyHal::enableFirmwareRoaming(fw_roaming_state_t state) {
return global_func_table_.wifi_enable_firmware_roaming(wlan_interface_handle_,
state);
}
wifi_error WifiLegacyHal::configureNdOffload(bool enable) {
return global_func_table_.wifi_configure_nd_offload(wlan_interface_handle_,
enable);
}
wifi_error WifiLegacyHal::startSendingOffloadedPacket(
uint32_t cmd_id,
const std::vector<uint8_t>& ip_packet_data,
const std::array<uint8_t, 6>& src_address,
const std::array<uint8_t, 6>& dst_address,
uint32_t period_in_ms) {
std::vector<uint8_t> ip_packet_data_internal(ip_packet_data);
std::vector<uint8_t> src_address_internal(
src_address.data(), src_address.data() + src_address.size());
std::vector<uint8_t> dst_address_internal(
dst_address.data(), dst_address.data() + dst_address.size());
return global_func_table_.wifi_start_sending_offloaded_packet(
cmd_id,
wlan_interface_handle_,
ip_packet_data_internal.data(),
ip_packet_data_internal.size(),
src_address_internal.data(),
dst_address_internal.data(),
period_in_ms);
}
wifi_error WifiLegacyHal::stopSendingOffloadedPacket(uint32_t cmd_id) {
return global_func_table_.wifi_stop_sending_offloaded_packet(
cmd_id, wlan_interface_handle_);
}
wifi_error WifiLegacyHal::setScanningMacOui(const std::array<uint8_t, 3>& oui) {
std::vector<uint8_t> oui_internal(oui.data(), oui.data() + oui.size());
return global_func_table_.wifi_set_scanning_mac_oui(wlan_interface_handle_,
oui_internal.data());
}
wifi_error WifiLegacyHal::selectTxPowerScenario(wifi_power_scenario scenario) {
return global_func_table_.wifi_select_tx_power_scenario(
wlan_interface_handle_, scenario);
}
wifi_error WifiLegacyHal::resetTxPowerScenario() {
return global_func_table_.wifi_reset_tx_power_scenario(wlan_interface_handle_);
}
std::pair<wifi_error, uint32_t> WifiLegacyHal::getLoggerSupportedFeatureSet() {
uint32_t supported_features;
wifi_error status = global_func_table_.wifi_get_logger_supported_feature_set(
wlan_interface_handle_, &supported_features);
return {status, supported_features};
}
wifi_error WifiLegacyHal::startPktFateMonitoring() {
return global_func_table_.wifi_start_pkt_fate_monitoring(
wlan_interface_handle_);
}
std::pair<wifi_error, std::vector<wifi_tx_report>>
WifiLegacyHal::getTxPktFates() {
std::vector<wifi_tx_report> tx_pkt_fates;
tx_pkt_fates.resize(MAX_FATE_LOG_LEN);
size_t num_fates = 0;
wifi_error status =
global_func_table_.wifi_get_tx_pkt_fates(wlan_interface_handle_,
tx_pkt_fates.data(),
tx_pkt_fates.size(),
&num_fates);
CHECK(num_fates <= MAX_FATE_LOG_LEN);
tx_pkt_fates.resize(num_fates);
return {status, std::move(tx_pkt_fates)};
}
std::pair<wifi_error, std::vector<wifi_rx_report>>
WifiLegacyHal::getRxPktFates() {
std::vector<wifi_rx_report> rx_pkt_fates;
rx_pkt_fates.resize(MAX_FATE_LOG_LEN);
size_t num_fates = 0;
wifi_error status =
global_func_table_.wifi_get_rx_pkt_fates(wlan_interface_handle_,
rx_pkt_fates.data(),
rx_pkt_fates.size(),
&num_fates);
CHECK(num_fates <= MAX_FATE_LOG_LEN);
rx_pkt_fates.resize(num_fates);
return {status, std::move(rx_pkt_fates)};
}
std::pair<wifi_error, WakeReasonStats> WifiLegacyHal::getWakeReasonStats() {
WakeReasonStats stats;
stats.cmd_event_wake_cnt.resize(kMaxWakeReasonStatsArraySize);
stats.driver_fw_local_wake_cnt.resize(kMaxWakeReasonStatsArraySize);
// This legacy struct needs separate memory to store the variable sized wake
// reason types.
stats.wake_reason_cnt.cmd_event_wake_cnt =
reinterpret_cast<int32_t*>(stats.cmd_event_wake_cnt.data());
stats.wake_reason_cnt.cmd_event_wake_cnt_sz = stats.cmd_event_wake_cnt.size();
stats.wake_reason_cnt.cmd_event_wake_cnt_used = 0;
stats.wake_reason_cnt.driver_fw_local_wake_cnt =
reinterpret_cast<int32_t*>(stats.driver_fw_local_wake_cnt.data());
stats.wake_reason_cnt.driver_fw_local_wake_cnt_sz =
stats.driver_fw_local_wake_cnt.size();
stats.wake_reason_cnt.driver_fw_local_wake_cnt_used = 0;
wifi_error status = global_func_table_.wifi_get_wake_reason_stats(
wlan_interface_handle_, &stats.wake_reason_cnt);
CHECK(stats.wake_reason_cnt.cmd_event_wake_cnt_used >= 0 &&
static_cast<uint32_t>(stats.wake_reason_cnt.cmd_event_wake_cnt_used) <=
kMaxWakeReasonStatsArraySize);
stats.cmd_event_wake_cnt.resize(
stats.wake_reason_cnt.cmd_event_wake_cnt_used);
stats.wake_reason_cnt.cmd_event_wake_cnt = nullptr;
CHECK(stats.wake_reason_cnt.driver_fw_local_wake_cnt_used >= 0 &&
static_cast<uint32_t>(
stats.wake_reason_cnt.driver_fw_local_wake_cnt_used) <=
kMaxWakeReasonStatsArraySize);
stats.driver_fw_local_wake_cnt.resize(
stats.wake_reason_cnt.driver_fw_local_wake_cnt_used);
stats.wake_reason_cnt.driver_fw_local_wake_cnt = nullptr;
return {status, stats};
}
wifi_error WifiLegacyHal::registerRingBufferCallbackHandler(
const on_ring_buffer_data_callback& on_user_data_callback) {
if (on_ring_buffer_data_internal_callback) {
return WIFI_ERROR_NOT_AVAILABLE;
}
on_ring_buffer_data_internal_callback = [on_user_data_callback](
char* ring_name,
char* buffer,
int buffer_size,
wifi_ring_buffer_status* status) {
if (status && buffer) {
std::vector<uint8_t> buffer_vector(
reinterpret_cast<uint8_t*>(buffer),
reinterpret_cast<uint8_t*>(buffer) + buffer_size);
on_user_data_callback(ring_name, buffer_vector, *status);
}
};
wifi_error status = global_func_table_.wifi_set_log_handler(
0, wlan_interface_handle_, {onAsyncRingBufferData});
if (status != WIFI_SUCCESS) {
on_ring_buffer_data_internal_callback = nullptr;
}
return status;
}
wifi_error WifiLegacyHal::deregisterRingBufferCallbackHandler() {
if (!on_ring_buffer_data_internal_callback) {
return WIFI_ERROR_NOT_AVAILABLE;
}
on_ring_buffer_data_internal_callback = nullptr;
return global_func_table_.wifi_reset_log_handler(0, wlan_interface_handle_);
}
std::pair<wifi_error, std::vector<wifi_ring_buffer_status>>
WifiLegacyHal::getRingBuffersStatus() {
std::vector<wifi_ring_buffer_status> ring_buffers_status;
ring_buffers_status.resize(kMaxRingBuffers);
uint32_t num_rings = kMaxRingBuffers;
wifi_error status = global_func_table_.wifi_get_ring_buffers_status(
wlan_interface_handle_, &num_rings, ring_buffers_status.data());
CHECK(num_rings <= kMaxRingBuffers);
ring_buffers_status.resize(num_rings);
return {status, std::move(ring_buffers_status)};
}
wifi_error WifiLegacyHal::startRingBufferLogging(const std::string& ring_name,
uint32_t verbose_level,
uint32_t max_interval_sec,
uint32_t min_data_size) {
return global_func_table_.wifi_start_logging(wlan_interface_handle_,
verbose_level,
0,
max_interval_sec,
min_data_size,
makeCharVec(ring_name).data());
}
wifi_error WifiLegacyHal::getRingBufferData(const std::string& ring_name) {
return global_func_table_.wifi_get_ring_data(wlan_interface_handle_,
makeCharVec(ring_name).data());
}
wifi_error WifiLegacyHal::registerErrorAlertCallbackHandler(
const on_error_alert_callback& on_user_alert_callback) {
if (on_error_alert_internal_callback) {
return WIFI_ERROR_NOT_AVAILABLE;
}
on_error_alert_internal_callback = [on_user_alert_callback](
wifi_request_id id, char* buffer, int buffer_size, int err_code) {
if (buffer) {
CHECK(id == 0);
on_user_alert_callback(
err_code,
std::vector<uint8_t>(
reinterpret_cast<uint8_t*>(buffer),
reinterpret_cast<uint8_t*>(buffer) + buffer_size));
}
};
wifi_error status = global_func_table_.wifi_set_alert_handler(
0, wlan_interface_handle_, {onAsyncErrorAlert});
if (status != WIFI_SUCCESS) {
on_error_alert_internal_callback = nullptr;
}
return status;
}
wifi_error WifiLegacyHal::deregisterErrorAlertCallbackHandler() {
if (!on_error_alert_internal_callback) {
return WIFI_ERROR_NOT_AVAILABLE;
}
on_error_alert_internal_callback = nullptr;
return global_func_table_.wifi_reset_alert_handler(0, wlan_interface_handle_);
}
wifi_error WifiLegacyHal::startRttRangeRequest(
wifi_request_id id,
const std::vector<wifi_rtt_config>& rtt_configs,
const on_rtt_results_callback& on_results_user_callback) {
if (on_rtt_results_internal_callback) {
return WIFI_ERROR_NOT_AVAILABLE;
}
on_rtt_results_internal_callback = [on_results_user_callback](
wifi_request_id id,
unsigned num_results,
wifi_rtt_result* rtt_results[]) {
if (num_results > 0 && !rtt_results) {
LOG(ERROR) << "Unexpected nullptr in RTT results";
return;
}
std::vector<const wifi_rtt_result*> rtt_results_vec;
std::copy_if(
rtt_results,
rtt_results + num_results,
back_inserter(rtt_results_vec),
[](wifi_rtt_result* rtt_result) { return rtt_result != nullptr; });
on_results_user_callback(id, rtt_results_vec);
};
std::vector<wifi_rtt_config> rtt_configs_internal(rtt_configs);
wifi_error status =
global_func_table_.wifi_rtt_range_request(id,
wlan_interface_handle_,
rtt_configs.size(),
rtt_configs_internal.data(),
{onAsyncRttResults});
if (status != WIFI_SUCCESS) {
on_rtt_results_internal_callback = nullptr;
}
return status;
}
wifi_error WifiLegacyHal::cancelRttRangeRequest(
wifi_request_id id, const std::vector<std::array<uint8_t, 6>>& mac_addrs) {
if (!on_rtt_results_internal_callback) {
return WIFI_ERROR_NOT_AVAILABLE;
}
static_assert(sizeof(mac_addr) == sizeof(std::array<uint8_t, 6>),
"MAC address size mismatch");
// TODO: How do we handle partial cancels (i.e only a subset of enabled mac
// addressed are cancelled).
std::vector<std::array<uint8_t, 6>> mac_addrs_internal(mac_addrs);
wifi_error status = global_func_table_.wifi_rtt_range_cancel(
id,
wlan_interface_handle_,
mac_addrs.size(),
reinterpret_cast<mac_addr*>(mac_addrs_internal.data()));
// If the request Id is wrong, don't stop the ongoing range request. Any
// other error should be treated as the end of rtt ranging.
if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
on_rtt_results_internal_callback = nullptr;
}
return status;
}
std::pair<wifi_error, wifi_rtt_capabilities>
WifiLegacyHal::getRttCapabilities() {
wifi_rtt_capabilities rtt_caps;
wifi_error status = global_func_table_.wifi_get_rtt_capabilities(
wlan_interface_handle_, &rtt_caps);
return {status, rtt_caps};
}
std::pair<wifi_error, wifi_rtt_responder> WifiLegacyHal::getRttResponderInfo() {
wifi_rtt_responder rtt_responder;
wifi_error status = global_func_table_.wifi_rtt_get_responder_info(
wlan_interface_handle_, &rtt_responder);
return {status, rtt_responder};
}
wifi_error WifiLegacyHal::enableRttResponder(
wifi_request_id id,
const wifi_channel_info& channel_hint,
uint32_t max_duration_secs,
const wifi_rtt_responder& info) {
wifi_rtt_responder info_internal(info);
return global_func_table_.wifi_enable_responder(id,
wlan_interface_handle_,
channel_hint,
max_duration_secs,
&info_internal);
}
wifi_error WifiLegacyHal::disableRttResponder(wifi_request_id id) {
return global_func_table_.wifi_disable_responder(id, wlan_interface_handle_);
}
wifi_error WifiLegacyHal::setRttLci(wifi_request_id id,
const wifi_lci_information& info) {
wifi_lci_information info_internal(info);
return global_func_table_.wifi_set_lci(
id, wlan_interface_handle_, &info_internal);
}
wifi_error WifiLegacyHal::setRttLcr(wifi_request_id id,
const wifi_lcr_information& info) {
wifi_lcr_information info_internal(info);
return global_func_table_.wifi_set_lcr(
id, wlan_interface_handle_, &info_internal);
}
wifi_error WifiLegacyHal::nanRegisterCallbackHandlers(
const NanCallbackHandlers& user_callbacks) {
on_nan_notify_response_user_callback = user_callbacks.on_notify_response;
on_nan_event_publish_terminated_user_callback =
user_callbacks.on_event_publish_terminated;
on_nan_event_match_user_callback = user_callbacks.on_event_match;
on_nan_event_match_expired_user_callback =
user_callbacks.on_event_match_expired;
on_nan_event_subscribe_terminated_user_callback =
user_callbacks.on_event_subscribe_terminated;
on_nan_event_followup_user_callback = user_callbacks.on_event_followup;
on_nan_event_disc_eng_event_user_callback =
user_callbacks.on_event_disc_eng_event;
on_nan_event_disabled_user_callback = user_callbacks.on_event_disabled;
on_nan_event_tca_user_callback = user_callbacks.on_event_tca;
on_nan_event_beacon_sdf_payload_user_callback =
user_callbacks.on_event_beacon_sdf_payload;
on_nan_event_data_path_request_user_callback =
user_callbacks.on_event_data_path_request;
on_nan_event_data_path_confirm_user_callback =
user_callbacks.on_event_data_path_confirm;
on_nan_event_data_path_end_user_callback =
user_callbacks.on_event_data_path_end;
on_nan_event_transmit_follow_up_user_callback =
user_callbacks.on_event_transmit_follow_up;
on_nan_event_range_request_user_callback =
user_callbacks.on_event_range_request;
on_nan_event_range_report_user_callback =
user_callbacks.on_event_range_report;
return global_func_table_.wifi_nan_register_handler(
wlan_interface_handle_,
{onAysncNanNotifyResponse,
onAysncNanEventPublishReplied,
onAysncNanEventPublishTerminated,
onAysncNanEventMatch,
onAysncNanEventMatchExpired,
onAysncNanEventSubscribeTerminated,
onAysncNanEventFollowup,
onAysncNanEventDiscEngEvent,
onAysncNanEventDisabled,
onAysncNanEventTca,
onAysncNanEventBeaconSdfPayload,
onAysncNanEventDataPathRequest,
onAysncNanEventDataPathConfirm,
onAysncNanEventDataPathEnd,
onAysncNanEventTransmitFollowUp,
onAysncNanEventRangeRequest,
onAysncNanEventRangeReport});
}
wifi_error WifiLegacyHal::nanEnableRequest(transaction_id id,
const NanEnableRequest& msg) {
NanEnableRequest msg_internal(msg);
return global_func_table_.wifi_nan_enable_request(
id, wlan_interface_handle_, &msg_internal);
}
wifi_error WifiLegacyHal::nanDisableRequest(transaction_id id) {
return global_func_table_.wifi_nan_disable_request(id,
wlan_interface_handle_);
}
wifi_error WifiLegacyHal::nanPublishRequest(transaction_id id,
const NanPublishRequest& msg) {
NanPublishRequest msg_internal(msg);
return global_func_table_.wifi_nan_publish_request(
id, wlan_interface_handle_, &msg_internal);
}
wifi_error WifiLegacyHal::nanPublishCancelRequest(
transaction_id id, const NanPublishCancelRequest& msg) {
NanPublishCancelRequest msg_internal(msg);
return global_func_table_.wifi_nan_publish_cancel_request(
id, wlan_interface_handle_, &msg_internal);
}
wifi_error WifiLegacyHal::nanSubscribeRequest(transaction_id id,
const NanSubscribeRequest& msg) {
NanSubscribeRequest msg_internal(msg);
return global_func_table_.wifi_nan_subscribe_request(
id, wlan_interface_handle_, &msg_internal);
}
wifi_error WifiLegacyHal::nanSubscribeCancelRequest(
transaction_id id, const NanSubscribeCancelRequest& msg) {
NanSubscribeCancelRequest msg_internal(msg);
return global_func_table_.wifi_nan_subscribe_cancel_request(
id, wlan_interface_handle_, &msg_internal);
}
wifi_error WifiLegacyHal::nanTransmitFollowupRequest(
transaction_id id, const NanTransmitFollowupRequest& msg) {
NanTransmitFollowupRequest msg_internal(msg);
return global_func_table_.wifi_nan_transmit_followup_request(
id, wlan_interface_handle_, &msg_internal);
}
wifi_error WifiLegacyHal::nanStatsRequest(transaction_id id,
const NanStatsRequest& msg) {
NanStatsRequest msg_internal(msg);
return global_func_table_.wifi_nan_stats_request(
id, wlan_interface_handle_, &msg_internal);
}
wifi_error WifiLegacyHal::nanConfigRequest(transaction_id id,
const NanConfigRequest& msg) {
NanConfigRequest msg_internal(msg);
return global_func_table_.wifi_nan_config_request(
id, wlan_interface_handle_, &msg_internal);
}
wifi_error WifiLegacyHal::nanTcaRequest(transaction_id id,
const NanTCARequest& msg) {
NanTCARequest msg_internal(msg);
return global_func_table_.wifi_nan_tca_request(
id, wlan_interface_handle_, &msg_internal);
}
wifi_error WifiLegacyHal::nanBeaconSdfPayloadRequest(
transaction_id id, const NanBeaconSdfPayloadRequest& msg) {
NanBeaconSdfPayloadRequest msg_internal(msg);
return global_func_table_.wifi_nan_beacon_sdf_payload_request(
id, wlan_interface_handle_, &msg_internal);
}
std::pair<wifi_error, NanVersion> WifiLegacyHal::nanGetVersion() {
NanVersion version;
wifi_error status =
global_func_table_.wifi_nan_get_version(global_handle_, &version);
return {status, version};
}
wifi_error WifiLegacyHal::nanGetCapabilities(transaction_id id) {
return global_func_table_.wifi_nan_get_capabilities(id,
wlan_interface_handle_);
}
wifi_error WifiLegacyHal::nanDataInterfaceCreate(
transaction_id id, const std::string& iface_name) {
return global_func_table_.wifi_nan_data_interface_create(
id, wlan_interface_handle_, makeCharVec(iface_name).data());
}
wifi_error WifiLegacyHal::nanDataInterfaceDelete(
transaction_id id, const std::string& iface_name) {
return global_func_table_.wifi_nan_data_interface_delete(
id, wlan_interface_handle_, makeCharVec(iface_name).data());
}
wifi_error WifiLegacyHal::nanDataRequestInitiator(
transaction_id id, const NanDataPathInitiatorRequest& msg) {
NanDataPathInitiatorRequest msg_internal(msg);
return global_func_table_.wifi_nan_data_request_initiator(
id, wlan_interface_handle_, &msg_internal);
}
wifi_error WifiLegacyHal::nanDataIndicationResponse(
transaction_id id, const NanDataPathIndicationResponse& msg) {
NanDataPathIndicationResponse msg_internal(msg);
return global_func_table_.wifi_nan_data_indication_response(
id, wlan_interface_handle_, &msg_internal);
}
typedef struct {
u8 num_ndp_instances;
NanDataPathId ndp_instance_id;
} NanDataPathEndSingleNdpIdRequest;
wifi_error WifiLegacyHal::nanDataEnd(transaction_id id,
uint32_t ndpInstanceId) {
NanDataPathEndSingleNdpIdRequest msg;
msg.num_ndp_instances = 1;
msg.ndp_instance_id = ndpInstanceId;
wifi_error status = global_func_table_.wifi_nan_data_end(
id, wlan_interface_handle_, (NanDataPathEndRequest*)&msg);
return status;
}
wifi_error WifiLegacyHal::setCountryCode(std::array<int8_t, 2> code) {
std::string code_str(code.data(), code.data() + code.size());
return global_func_table_.wifi_set_country_code(wlan_interface_handle_,
code_str.c_str());
}
wifi_error WifiLegacyHal::retrieveWlanInterfaceHandle() {
const std::string& ifname_to_find = getStaIfaceName();
wifi_interface_handle* iface_handles = nullptr;
int num_iface_handles = 0;
wifi_error status = global_func_table_.wifi_get_ifaces(
global_handle_, &num_iface_handles, &iface_handles);
if (status != WIFI_SUCCESS) {
LOG(ERROR) << "Failed to enumerate interface handles";
return status;
}
for (int i = 0; i < num_iface_handles; ++i) {
std::array<char, IFNAMSIZ> current_ifname;
current_ifname.fill(0);
status = global_func_table_.wifi_get_iface_name(
iface_handles[i], current_ifname.data(), current_ifname.size());
if (status != WIFI_SUCCESS) {
LOG(WARNING) << "Failed to get interface handle name";
continue;
}
if (ifname_to_find == current_ifname.data()) {
wlan_interface_handle_ = iface_handles[i];
return WIFI_SUCCESS;
}
}
return WIFI_ERROR_UNKNOWN;
}
void WifiLegacyHal::runEventLoop() {
LOG(DEBUG) << "Starting legacy HAL event loop";
global_func_table_.wifi_event_loop(global_handle_);
const auto lock = hidl_sync_util::acquireGlobalLock();
if (!awaiting_event_loop_termination_) {
LOG(FATAL) << "Legacy HAL event loop terminated, but HAL was not stopping";
}
LOG(DEBUG) << "Legacy HAL event loop terminated";
awaiting_event_loop_termination_ = false;
stop_wait_cv_.notify_one();
}
std::pair<wifi_error, std::vector<wifi_cached_scan_results>>
WifiLegacyHal::getGscanCachedResults() {
std::vector<wifi_cached_scan_results> cached_scan_results;
cached_scan_results.resize(kMaxCachedGscanResults);
int32_t num_results = 0;
wifi_error status = global_func_table_.wifi_get_cached_gscan_results(
wlan_interface_handle_,
true /* always flush */,
cached_scan_results.size(),
cached_scan_results.data(),
&num_results);
CHECK(num_results >= 0 &&
static_cast<uint32_t>(num_results) <= kMaxCachedGscanResults);
cached_scan_results.resize(num_results);
// Check for invalid IE lengths in these cached scan results and correct it.
for (auto& cached_scan_result : cached_scan_results) {
int num_scan_results = cached_scan_result.num_results;
for (int i = 0; i < num_scan_results; i++) {
auto& scan_result = cached_scan_result.results[i];
if (scan_result.ie_length > 0) {
LOG(DEBUG) << "Cached scan result has non-zero IE length "
<< scan_result.ie_length;
scan_result.ie_length = 0;
}
}
}
return {status, std::move(cached_scan_results)};
}
void WifiLegacyHal::invalidate() {
global_handle_ = nullptr;
wlan_interface_handle_ = nullptr;
on_driver_memory_dump_internal_callback = nullptr;
on_firmware_memory_dump_internal_callback = nullptr;
on_gscan_event_internal_callback = nullptr;
on_gscan_full_result_internal_callback = nullptr;
on_link_layer_stats_result_internal_callback = nullptr;
on_rssi_threshold_breached_internal_callback = nullptr;
on_ring_buffer_data_internal_callback = nullptr;
on_error_alert_internal_callback = nullptr;
on_rtt_results_internal_callback = nullptr;
on_nan_notify_response_user_callback = nullptr;
on_nan_event_publish_terminated_user_callback = nullptr;
on_nan_event_match_user_callback = nullptr;
on_nan_event_match_expired_user_callback = nullptr;
on_nan_event_subscribe_terminated_user_callback = nullptr;
on_nan_event_followup_user_callback = nullptr;
on_nan_event_disc_eng_event_user_callback = nullptr;
on_nan_event_disabled_user_callback = nullptr;
on_nan_event_tca_user_callback = nullptr;
on_nan_event_beacon_sdf_payload_user_callback = nullptr;
on_nan_event_data_path_request_user_callback = nullptr;
on_nan_event_data_path_confirm_user_callback = nullptr;
on_nan_event_data_path_end_user_callback = nullptr;
on_nan_event_transmit_follow_up_user_callback = nullptr;
on_nan_event_range_request_user_callback = nullptr;
on_nan_event_range_report_user_callback = nullptr;
}
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_1
} // namespace wifi
} // namespace hardware
} // namespace android