From 8714a3e1036c6c432f6422c0bb1f6dc4a96d0d4a Mon Sep 17 00:00:00 2001 From: Roshan Pius Date: Fri, 28 Oct 2016 10:43:51 -0700 Subject: [PATCH 1/3] wifi: Add logger/debug API wrappers in WifiLegacyHal Legacy HAL wrappers for the following debug functions: 1. Wake reason stats 2. Packet fate 3. Supported feature set 4. Ring buffer. Bug: 32221997 Test: Compiles Change-Id: Ie6c03aeefb0b6e711419cfa5451cddbeb3069cd0 --- wifi/1.0/default/wifi_legacy_hal.cpp | 148 +++++++++++++++++++++++++++ wifi/1.0/default/wifi_legacy_hal.h | 32 ++++++ 2 files changed, 180 insertions(+) diff --git a/wifi/1.0/default/wifi_legacy_hal.cpp b/wifi/1.0/default/wifi_legacy_hal.cpp index 15b6bfc74f..135e2c514d 100644 --- a/wifi/1.0/default/wifi_legacy_hal.cpp +++ b/wifi/1.0/default/wifi_legacy_hal.cpp @@ -36,6 +36,8 @@ 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; // Legacy HAL functions accept "C" style function pointers, so use global // functions to pass to the legacy HAL function and store the corresponding @@ -97,6 +99,19 @@ void onLinkLayerStatsDataResult(wifi_request_id id, } } +// Callback to be invoked for ring buffer data indication. +std::function + on_ring_buffer_data_internal_callback; +void onRingBufferData(char* ring_name, + char* buffer, + int buffer_size, + wifi_ring_buffer_status* status) { + if (on_ring_buffer_data_internal_callback) { + on_ring_buffer_data_internal_callback( + ring_name, buffer, buffer_size, status); + } +} + // End of the free-standing "C" style callbacks. WifiLegacyHal::WifiLegacyHal() @@ -402,6 +417,138 @@ std::pair WifiLegacyHal::getLinkLayerStats() { return {status, link_stats}; } +std::pair 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> +WifiLegacyHal::getTxPktFates() { + std::vector 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> +WifiLegacyHal::getRxPktFates() { + std::vector 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 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(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(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(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( + 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 buffer_vector( + reinterpret_cast(buffer), + reinterpret_cast(buffer) + buffer_size); + on_user_data_callback(ring_name, buffer_vector, *status); + } + }; + return global_func_table_.wifi_set_log_handler( + 0, wlan_interface_handle_, {onRingBufferData}); +} + +std::pair> +WifiLegacyHal::getRingBuffersStatus() { + std::vector ring_buffers_status; + ring_buffers_status.resize(kMaxRingBuffers); + uint32_t num_rings = 0; + 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) { + std::vector ring_name_internal(ring_name.begin(), ring_name.end()); + return global_func_table_.wifi_start_logging(wlan_interface_handle_, + verbose_level, + 0, + max_interval_sec, + min_data_size, + ring_name_internal.data()); +} + +wifi_error WifiLegacyHal::getRingBufferData(const std::string& ring_name) { + std::vector ring_name_internal(ring_name.begin(), ring_name.end()); + return global_func_table_.wifi_get_ring_data(wlan_interface_handle_, + ring_name_internal.data()); +} + wifi_error WifiLegacyHal::retrieveWlanInterfaceHandle() { const std::string& ifname_to_find = getStaIfaceName(); wifi_interface_handle* iface_handles = nullptr; @@ -479,6 +626,7 @@ void WifiLegacyHal::invalidate() { on_gscan_event_internal_callback = nullptr; on_gscan_full_result_internal_callback = nullptr; on_link_layer_stats_result_internal_callback = nullptr; + on_ring_buffer_data_internal_callback = nullptr; } } // namespace legacy_hal diff --git a/wifi/1.0/default/wifi_legacy_hal.h b/wifi/1.0/default/wifi_legacy_hal.h index df1c3d6cea..3dc98adcd6 100644 --- a/wifi/1.0/default/wifi_legacy_hal.h +++ b/wifi/1.0/default/wifi_legacy_hal.h @@ -54,6 +54,17 @@ struct LinkLayerStats { }; #pragma GCC diagnostic pop +// The |WLAN_DRIVER_WAKE_REASON_CNT.cmd_event_wake_cnt| and +// |WLAN_DRIVER_WAKE_REASON_CNT.driver_fw_local_wake_cnt| stats is provided +// as a pointer in |WLAN_DRIVER_WAKE_REASON_CNT| structure in the legacy HAL +// API. Separate that out into a separate return elements to avoid passing +// pointers around. +struct WakeReasonStats { + WLAN_DRIVER_WAKE_REASON_CNT wake_reason_cnt; + std::vector cmd_event_wake_cnt; + std::vector driver_fw_local_wake_cnt; +}; + // Full scan results contain IE info and are hence passed by reference, to // preserve the variable length array member |ie_data|. Callee must not retain // the pointer. @@ -64,6 +75,12 @@ using on_gscan_full_result_callback = using on_gscan_results_callback = std::function&)>; +// Callback for ring buffer data. +using on_ring_buffer_data_callback = + std::function&, + const wifi_ring_buffer_status&)>; + /** * Class that encapsulates all legacy HAL interactions. * This class manages the lifetime of the event loop thread used by legacy HAL. @@ -115,6 +132,21 @@ class WifiLegacyHal { wifi_error enableLinkLayerStats(bool debug); wifi_error disableLinkLayerStats(); std::pair getLinkLayerStats(); + // Logger/debug functions. + std::pair getLoggerSupportedFeatureSet(); + wifi_error startPktFateMonitoring(); + std::pair> getTxPktFates(); + std::pair> getRxPktFates(); + std::pair getWakeReasonStats(); + wifi_error registerRingBufferCallbackHandler( + const on_ring_buffer_data_callback& on_data_callback); + std::pair> + getRingBuffersStatus(); + wifi_error startRingBufferLogging(const std::string& ring_name, + uint32_t verbose_level, + uint32_t max_interval_sec, + uint32_t min_data_size); + wifi_error getRingBufferData(const std::string& ring_name); private: // Retrieve the interface handle to be used for the "wlan" interface. From d8e915ab9964f8ab27afec41fe77476384c520d2 Mon Sep 17 00:00:00 2001 From: Roshan Pius Date: Fri, 28 Oct 2016 11:23:11 -0700 Subject: [PATCH 2/3] wifi: Add RTT API wrappers in WifiLegacyHal These are just wrapper methods over the legacy RTT related HAL API's. Note: Some of the RTT related API's have been intentionally left off because they're no longer used. Bug: 31991232 Test: Compiles Change-Id: Ied19d9ec1d4347ead0c40ab3683a1a0bae704f90 --- wifi/1.0/default/wifi_legacy_hal.cpp | 115 +++++++++++++++++++++++++++ wifi/1.0/default/wifi_legacy_hal.h | 23 ++++++ 2 files changed, 138 insertions(+) diff --git a/wifi/1.0/default/wifi_legacy_hal.cpp b/wifi/1.0/default/wifi_legacy_hal.cpp index 135e2c514d..46482aaf7f 100644 --- a/wifi/1.0/default/wifi_legacy_hal.cpp +++ b/wifi/1.0/default/wifi_legacy_hal.cpp @@ -112,6 +112,18 @@ void onRingBufferData(char* ring_name, } } +// Callback to be invoked for rtt results results. +std::function + on_rtt_results_internal_callback; +void onRttResults(wifi_request_id id, + unsigned num_results, + wifi_rtt_result* rtt_results[]) { + if (on_rtt_results_internal_callback) { + on_rtt_results_internal_callback(id, num_results, rtt_results); + } +} + // End of the free-standing "C" style callbacks. WifiLegacyHal::WifiLegacyHal() @@ -549,6 +561,108 @@ wifi_error WifiLegacyHal::getRingBufferData(const std::string& ring_name) { ring_name_internal.data()); } +wifi_error WifiLegacyHal::startRttRangeRequest( + wifi_request_id id, + const std::vector& 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 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 rtt_configs_internal(rtt_configs); + return global_func_table_.wifi_rtt_range_request(id, + wlan_interface_handle_, + rtt_configs.size(), + rtt_configs_internal.data(), + {onRttResults}); +} + +wifi_error WifiLegacyHal::cancelRttRangeRequest( + wifi_request_id id, const std::vector>& mac_addrs) { + if (!on_rtt_results_internal_callback) { + return WIFI_ERROR_NOT_AVAILABLE; + } + static_assert(sizeof(mac_addr) == sizeof(std::array), + "MAC address size mismatch"); + // TODO: How do we handle partial cancels (i.e only a subset of enabled mac + // addressed are cancelled). + std::vector> 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_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 +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 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::retrieveWlanInterfaceHandle() { const std::string& ifname_to_find = getStaIfaceName(); wifi_interface_handle* iface_handles = nullptr; @@ -627,6 +741,7 @@ void WifiLegacyHal::invalidate() { on_gscan_full_result_internal_callback = nullptr; on_link_layer_stats_result_internal_callback = nullptr; on_ring_buffer_data_internal_callback = nullptr; + on_rtt_results_internal_callback = nullptr; } } // namespace legacy_hal diff --git a/wifi/1.0/default/wifi_legacy_hal.h b/wifi/1.0/default/wifi_legacy_hal.h index 3dc98adcd6..0bb78b2a44 100644 --- a/wifi/1.0/default/wifi_legacy_hal.h +++ b/wifi/1.0/default/wifi_legacy_hal.h @@ -75,6 +75,13 @@ using on_gscan_full_result_callback = using on_gscan_results_callback = std::function&)>; +// Callback for RTT range request results. +// Rtt results contain IE info and are hence passed by reference, to +// preserve the |LCI| and |LCR| pointers. Callee must not retain +// the pointer. +using on_rtt_results_callback = std::function&)>; + // Callback for ring buffer data. using on_ring_buffer_data_callback = std::function& rtt_configs, + const on_rtt_results_callback& on_results_callback); + wifi_error cancelRttRangeRequest( + wifi_request_id id, const std::vector>& mac_addrs); + std::pair getRttCapabilities(); + std::pair getRttResponderInfo(); + wifi_error enableRttResponder(wifi_request_id id, + const wifi_channel_info& channel_hint, + uint32_t max_duration_secs, + const wifi_rtt_responder& info); + wifi_error disableRttResponder(wifi_request_id id); + wifi_error setRttLci(wifi_request_id id, const wifi_lci_information& info); + wifi_error setRttLcr(wifi_request_id id, const wifi_lcr_information& info); private: // Retrieve the interface handle to be used for the "wlan" interface. From 2301209a9a2ae0a1f86bb847f9b94519ff070562 Mon Sep 17 00:00:00 2001 From: Roshan Pius Date: Fri, 28 Oct 2016 11:27:40 -0700 Subject: [PATCH 3/3] wifi: Add NAN API wrappers in WifiLegacyHal NAN API's are inherently asynchronous. So, add a function for registering the various callbacks and add wrappers for all other NAN API's. Bug: 31991076 Test: Compiles Change-Id: I304a5d9d41b684f0778e0ace3601380153068e12 --- wifi/1.0/default/wifi_legacy_hal.cpp | 290 +++++++++++++++++++++++++++ wifi/1.0/default/wifi_legacy_hal.h | 53 +++++ 2 files changed, 343 insertions(+) diff --git a/wifi/1.0/default/wifi_legacy_hal.cpp b/wifi/1.0/default/wifi_legacy_hal.cpp index 46482aaf7f..560a273568 100644 --- a/wifi/1.0/default/wifi_legacy_hal.cpp +++ b/wifi/1.0/default/wifi_legacy_hal.cpp @@ -124,6 +124,116 @@ void onRttResults(wifi_request_id id, } } +// 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 + on_nan_notify_response_user_callback; +void onNanNotifyResponse(transaction_id id, NanResponseMsg* msg) { + if (on_nan_notify_response_user_callback && msg) { + on_nan_notify_response_user_callback(id, *msg); + } +} + +std::function + on_nan_event_publish_terminated_user_callback; +void onNanEventPublishTerminated(NanPublishTerminatedInd* event) { + if (on_nan_event_publish_terminated_user_callback && event) { + on_nan_event_publish_terminated_user_callback(*event); + } +} + +std::function on_nan_event_match_user_callback; +void onNanEventMatch(NanMatchInd* event) { + if (on_nan_event_match_user_callback && event) { + on_nan_event_match_user_callback(*event); + } +} + +std::function + on_nan_event_match_expired_user_callback; +void onNanEventMatchExpired(NanMatchExpiredInd* event) { + if (on_nan_event_match_expired_user_callback && event) { + on_nan_event_match_expired_user_callback(*event); + } +} + +std::function + on_nan_event_subscribe_terminated_user_callback; +void onNanEventSubscribeTerminated(NanSubscribeTerminatedInd* event) { + if (on_nan_event_subscribe_terminated_user_callback && event) { + on_nan_event_subscribe_terminated_user_callback(*event); + } +} + +std::function on_nan_event_followup_user_callback; +void onNanEventFollowup(NanFollowupInd* event) { + if (on_nan_event_followup_user_callback && event) { + on_nan_event_followup_user_callback(*event); + } +} + +std::function + on_nan_event_disc_eng_event_user_callback; +void onNanEventDiscEngEvent(NanDiscEngEventInd* event) { + if (on_nan_event_disc_eng_event_user_callback && event) { + on_nan_event_disc_eng_event_user_callback(*event); + } +} + +std::function on_nan_event_disabled_user_callback; +void onNanEventDisabled(NanDisabledInd* event) { + if (on_nan_event_disabled_user_callback && event) { + on_nan_event_disabled_user_callback(*event); + } +} + +std::function on_nan_event_tca_user_callback; +void onNanEventTca(NanTCAInd* event) { + if (on_nan_event_tca_user_callback && event) { + on_nan_event_tca_user_callback(*event); + } +} + +std::function + on_nan_event_beacon_sdf_payload_user_callback; +void onNanEventBeaconSdfPayload(NanBeaconSdfPayloadInd* event) { + if (on_nan_event_beacon_sdf_payload_user_callback && event) { + on_nan_event_beacon_sdf_payload_user_callback(*event); + } +} + +std::function + on_nan_event_data_path_request_user_callback; +void onNanEventDataPathRequest(NanDataPathRequestInd* event) { + if (on_nan_event_data_path_request_user_callback && event) { + on_nan_event_data_path_request_user_callback(*event); + } +} +std::function + on_nan_event_data_path_confirm_user_callback; +void onNanEventDataPathConfirm(NanDataPathConfirmInd* event) { + if (on_nan_event_data_path_confirm_user_callback && event) { + on_nan_event_data_path_confirm_user_callback(*event); + } +} + +std::function + on_nan_event_data_path_end_user_callback; +void onNanEventDataPathEnd(NanDataPathEndInd* event) { + if (on_nan_event_data_path_end_user_callback && event) { + on_nan_event_data_path_end_user_callback(*event); + } +} + +std::function + on_nan_event_transmit_follow_up_user_callback; +void onNanEventTransmitFollowUp(NanTransmitFollowupInd* event) { + if (on_nan_event_transmit_follow_up_user_callback && event) { + on_nan_event_transmit_follow_up_user_callback(*event); + } +} // End of the free-standing "C" style callbacks. WifiLegacyHal::WifiLegacyHal() @@ -663,6 +773,172 @@ wifi_error WifiLegacyHal::setRttLcr(wifi_request_id id, 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; + + return global_func_table_.wifi_nan_register_handler( + wlan_interface_handle_, + {onNanNotifyResponse, + onNanEventPublishTerminated, + onNanEventMatch, + onNanEventMatchExpired, + onNanEventSubscribeTerminated, + onNanEventFollowup, + onNanEventDiscEngEvent, + onNanEventDisabled, + onNanEventTca, + onNanEventBeaconSdfPayload, + onNanEventDataPathRequest, + onNanEventDataPathConfirm, + onNanEventDataPathEnd, + onNanEventTransmitFollowUp}); +} + +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 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) { + std::vector iface_name_internal(iface_name.begin(), iface_name.end()); + return global_func_table_.wifi_nan_data_interface_create( + id, wlan_interface_handle_, iface_name_internal.data()); +} + +wifi_error WifiLegacyHal::nanDataInterfaceDelete( + transaction_id id, const std::string& iface_name) { + std::vector iface_name_internal(iface_name.begin(), iface_name.end()); + return global_func_table_.wifi_nan_data_interface_delete( + id, wlan_interface_handle_, iface_name_internal.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); +} + +wifi_error WifiLegacyHal::nanDataEnd(transaction_id id, + const NanDataPathEndRequest& msg) { + NanDataPathEndRequest msg_internal(msg); + return global_func_table_.wifi_nan_data_end( + id, wlan_interface_handle_, &msg_internal); +} + wifi_error WifiLegacyHal::retrieveWlanInterfaceHandle() { const std::string& ifname_to_find = getStaIfaceName(); wifi_interface_handle* iface_handles = nullptr; @@ -742,6 +1018,20 @@ void WifiLegacyHal::invalidate() { on_link_layer_stats_result_internal_callback = nullptr; on_ring_buffer_data_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; } } // namespace legacy_hal diff --git a/wifi/1.0/default/wifi_legacy_hal.h b/wifi/1.0/default/wifi_legacy_hal.h index 0bb78b2a44..62b773eb15 100644 --- a/wifi/1.0/default/wifi_legacy_hal.h +++ b/wifi/1.0/default/wifi_legacy_hal.h @@ -65,6 +65,30 @@ struct WakeReasonStats { std::vector driver_fw_local_wake_cnt; }; +// NAN response and event callbacks struct. +struct NanCallbackHandlers { + // NotifyResponse invoked to notify the status of the Request. + std::function on_notify_response; + // Various event callbacks. + std::function + on_event_publish_terminated; + std::function on_event_match; + std::function on_event_match_expired; + std::function + on_event_subscribe_terminated; + std::function on_event_followup; + std::function on_event_disc_eng_event; + std::function on_event_disabled; + std::function on_event_tca; + std::function + on_event_beacon_sdf_payload; + std::function on_event_data_path_request; + std::function on_event_data_path_confirm; + std::function on_event_data_path_end; + std::function + on_event_transmit_follow_up; +}; + // Full scan results contain IE info and are hence passed by reference, to // preserve the variable length array member |ie_data|. Callee must not retain // the pointer. @@ -170,6 +194,35 @@ class WifiLegacyHal { wifi_error disableRttResponder(wifi_request_id id); wifi_error setRttLci(wifi_request_id id, const wifi_lci_information& info); wifi_error setRttLcr(wifi_request_id id, const wifi_lcr_information& info); + // NAN functions. + wifi_error nanRegisterCallbackHandlers(const NanCallbackHandlers& callbacks); + wifi_error nanEnableRequest(transaction_id id, const NanEnableRequest& msg); + wifi_error nanDisableRequest(transaction_id id); + wifi_error nanPublishRequest(transaction_id id, const NanPublishRequest& msg); + wifi_error nanPublishCancelRequest(transaction_id id, + const NanPublishCancelRequest& msg); + wifi_error nanSubscribeRequest(transaction_id id, + const NanSubscribeRequest& msg); + wifi_error nanSubscribeCancelRequest(transaction_id id, + const NanSubscribeCancelRequest& msg); + wifi_error nanTransmitFollowupRequest(transaction_id id, + const NanTransmitFollowupRequest& msg); + wifi_error nanStatsRequest(transaction_id id, const NanStatsRequest& msg); + wifi_error nanConfigRequest(transaction_id id, const NanConfigRequest& msg); + wifi_error nanTcaRequest(transaction_id id, const NanTCARequest& msg); + wifi_error nanBeaconSdfPayloadRequest(transaction_id id, + const NanBeaconSdfPayloadRequest& msg); + std::pair nanGetVersion(); + wifi_error nanGetCapabilities(transaction_id id); + wifi_error nanDataInterfaceCreate(transaction_id id, + const std::string& iface_name); + wifi_error nanDataInterfaceDelete(transaction_id id, + const std::string& iface_name); + wifi_error nanDataRequestInitiator(transaction_id id, + const NanDataPathInitiatorRequest& msg); + wifi_error nanDataIndicationResponse( + transaction_id id, const NanDataPathIndicationResponse& msg); + wifi_error nanDataEnd(transaction_id id, const NanDataPathEndRequest& msg); private: // Retrieve the interface handle to be used for the "wlan" interface.