1 /* 2 * Copyright (C) 2022 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef WIFI_LEGACY_HAL_H_ 18 #define WIFI_LEGACY_HAL_H_ 19 20 #include <hardware_legacy/wifi_hal.h> 21 #include <wifi_system/interface_tool.h> 22 23 #include <condition_variable> 24 #include <functional> 25 #include <map> 26 #include <mutex> 27 #include <thread> 28 #include <vector> 29 30 namespace aidl { 31 namespace android { 32 namespace hardware { 33 namespace wifi { 34 // This is in a separate namespace to prevent typename conflicts between 35 // the legacy HAL types and the AIDL interface types. 36 namespace legacy_hal { 37 // Import all the types defined inside the legacy HAL header files into this 38 // namespace. 39 using ::chre_nan_rtt_state; 40 using ::frame_info; 41 using ::frame_type; 42 using ::FRAME_TYPE_80211_MGMT; 43 using ::FRAME_TYPE_ETHERNET_II; 44 using ::FRAME_TYPE_UNKNOWN; 45 using ::fw_roaming_state_t; 46 using ::mac_addr; 47 using ::NAN_BOOTSTRAPPING_INITIATOR_RESPONSE; 48 using ::NAN_BOOTSTRAPPING_RESPONDER_RESPONSE; 49 using ::NAN_CHANNEL_24G_BAND; 50 using ::NAN_CHANNEL_5G_BAND_HIGH; 51 using ::NAN_CHANNEL_5G_BAND_LOW; 52 using ::NAN_DISABLE_RANGE_REPORT; 53 using ::NAN_DO_NOT_USE_SRF; 54 using ::NAN_DP_CHANNEL_NOT_REQUESTED; 55 using ::NAN_DP_CONFIG_NO_SECURITY; 56 using ::NAN_DP_CONFIG_SECURITY; 57 using ::NAN_DP_END; 58 using ::NAN_DP_FORCE_CHANNEL_SETUP; 59 using ::NAN_DP_INITIATOR_RESPONSE; 60 using ::NAN_DP_INTERFACE_CREATE; 61 using ::NAN_DP_INTERFACE_DELETE; 62 using ::NAN_DP_REQUEST_ACCEPT; 63 using ::NAN_DP_REQUEST_CHANNEL_SETUP; 64 using ::NAN_DP_REQUEST_REJECT; 65 using ::NAN_DP_RESPONDER_RESPONSE; 66 using ::NAN_ENABLE_RANGE_REPORT; 67 using ::NAN_GET_CAPABILITIES; 68 using ::NAN_MATCH_ALG_MATCH_CONTINUOUS; 69 using ::NAN_MATCH_ALG_MATCH_NEVER; 70 using ::NAN_MATCH_ALG_MATCH_ONCE; 71 using ::NAN_PAIRING_END; 72 using ::NAN_PAIRING_INITIATOR_RESPONSE; 73 using ::NAN_PAIRING_RESPONDER_RESPONSE; 74 using ::NAN_PAIRING_SETUP; 75 using ::NAN_PAIRING_VERIFICATION; 76 using ::NAN_PUBLISH_TYPE_SOLICITED; 77 using ::NAN_PUBLISH_TYPE_UNSOLICITED; 78 using ::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED; 79 using ::NAN_RANGING_AUTO_RESPONSE_DISABLE; 80 using ::NAN_RANGING_AUTO_RESPONSE_ENABLE; 81 using ::NAN_RANGING_DISABLE; 82 using ::NAN_RANGING_ENABLE; 83 using ::NAN_RESPONSE_BEACON_SDF_PAYLOAD; 84 using ::NAN_RESPONSE_CONFIG; 85 using ::NAN_RESPONSE_DISABLED; 86 using ::NAN_RESPONSE_ENABLED; 87 using ::NAN_RESPONSE_ERROR; 88 using ::NAN_RESPONSE_PUBLISH; 89 using ::NAN_RESPONSE_PUBLISH_CANCEL; 90 using ::NAN_RESPONSE_STATS; 91 using ::NAN_RESPONSE_SUBSCRIBE; 92 using ::NAN_RESPONSE_SUBSCRIBE_CANCEL; 93 using ::NAN_RESPONSE_TCA; 94 using ::NAN_RESPONSE_TRANSMIT_FOLLOWUP; 95 using ::NAN_RESUME_REQUEST_RESPONSE; 96 using ::NAN_SECURITY_KEY_INPUT_PASSPHRASE; 97 using ::NAN_SECURITY_KEY_INPUT_PMK; 98 using ::NAN_SERVICE_ACCEPT_POLICY_ALL; 99 using ::NAN_SERVICE_ACCEPT_POLICY_NONE; 100 using ::NAN_SRF_ATTR_BLOOM_FILTER; 101 using ::NAN_SRF_ATTR_PARTIAL_MAC_ADDR; 102 using ::NAN_SRF_INCLUDE_DO_NOT_RESPOND; 103 using ::NAN_SRF_INCLUDE_RESPOND; 104 using ::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND; 105 using ::NAN_SSI_REQUIRED_IN_MATCH_IND; 106 using ::NAN_STATUS_ALREADY_ENABLED; 107 using ::NAN_STATUS_FOLLOWUP_QUEUE_FULL; 108 using ::NAN_STATUS_INTERNAL_FAILURE; 109 using ::NAN_STATUS_INVALID_BOOTSTRAPPING_ID; 110 using ::NAN_STATUS_INVALID_NDP_ID; 111 using ::NAN_STATUS_INVALID_PAIRING_ID; 112 using ::NAN_STATUS_INVALID_PARAM; 113 using ::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID; 114 using ::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID; 115 using ::NAN_STATUS_NAN_NOT_ALLOWED; 116 using ::NAN_STATUS_NO_CONNECTION; 117 using ::NAN_STATUS_NO_OTA_ACK; 118 using ::NAN_STATUS_NO_RESOURCE_AVAILABLE; 119 using ::NAN_STATUS_NOT_SUPPORTED; 120 using ::NAN_STATUS_PROTOCOL_FAILURE; 121 using ::NAN_STATUS_REDUNDANT_REQUEST; 122 using ::NAN_STATUS_SUCCESS; 123 using ::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED; 124 using ::NAN_SUBSCRIBE_TYPE_ACTIVE; 125 using ::NAN_SUBSCRIBE_TYPE_PASSIVE; 126 using ::NAN_SUSPEND_REQUEST_RESPONSE; 127 using ::NAN_TRANSMIT_IN_DW; 128 using ::NAN_TRANSMIT_IN_FAW; 129 using ::NAN_TX_PRIORITY_HIGH; 130 using ::NAN_TX_PRIORITY_NORMAL; 131 using ::NAN_TX_TYPE_BROADCAST; 132 using ::NAN_TX_TYPE_UNICAST; 133 using ::NAN_USE_SRF; 134 using ::NanAkm; 135 using ::NanBeaconSdfPayloadInd; 136 using ::NanBootstrappingConfirmInd; 137 using ::NanBootstrappingIndicationResponse; 138 using ::NanBootstrappingRequest; 139 using ::NanBootstrappingRequestInd; 140 using ::NanBootstrappingRequestResponse; 141 using ::NanBootstrappingResponseCode; 142 using ::NanCapabilities; 143 using ::NanChannelInfo; 144 using ::NanConfigRequest; 145 using ::NanDataPathChannelCfg; 146 using ::NanDataPathConfirmInd; 147 using ::NanDataPathEndInd; 148 using ::NanDataPathIndicationResponse; 149 using ::NanDataPathInitiatorRequest; 150 using ::NanDataPathRequestInd; 151 using ::NanDataPathScheduleUpdateInd; 152 using ::NanDisabledInd; 153 using ::NanDiscEngEventInd; 154 using ::NanEnableRequest; 155 using ::NanFollowupInd; 156 using ::NanIdentityResolutionAttribute; 157 using ::NanMatchAlg; 158 using ::NanMatchExpiredInd; 159 using ::NanMatchInd; 160 using ::NanPairingConfig; 161 using ::NanPairingConfirmInd; 162 using ::NanPairingEndRequest; 163 using ::NanPairingIndicationResponse; 164 using ::NanPairingRequest; 165 using ::NanPairingRequestInd; 166 using ::NanPairingRequestResponse; 167 using ::NanPairingRequestType; 168 using ::NanPairingResponseCode; 169 using ::NanPublishCancelRequest; 170 using ::NanPublishRequest; 171 using ::NanPublishTerminatedInd; 172 using ::NanPublishType; 173 using ::NanRangeReportInd; 174 using ::NanRangeRequestInd; 175 using ::NanResponseMsg; 176 using ::NanResumeRequest; 177 using ::NanSRFType; 178 using ::NanStatusType; 179 using ::NanSubscribeCancelRequest; 180 using ::NanSubscribeRequest; 181 using ::NanSubscribeTerminatedInd; 182 using ::NanSubscribeType; 183 using ::NanSuspendRequest; 184 using ::NanSuspensionModeChangeInd; 185 using ::NanTransmitFollowupInd; 186 using ::NanTransmitFollowupRequest; 187 using ::NanTxType; 188 using ::NpkSecurityAssociation; 189 using ::PASN; 190 using ::ROAMING_AGGRESSIVE; 191 using ::ROAMING_DISABLE; 192 using ::ROAMING_ENABLE; 193 using ::RTT_PEER_AP; 194 using ::RTT_PEER_NAN; 195 using ::RTT_PEER_P2P_CLIENT; 196 using ::RTT_PEER_P2P_GO; 197 using ::RTT_PEER_STA; 198 using ::rtt_peer_type; 199 using ::RTT_STATUS_ABORTED; 200 using ::RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL; 201 using ::RTT_STATUS_FAIL_BUSY_TRY_LATER; 202 using ::RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE; 203 using ::RTT_STATUS_FAIL_INVALID_TS; 204 using ::RTT_STATUS_FAIL_NO_CAPABILITY; 205 using ::RTT_STATUS_FAIL_NO_RSP; 206 using ::RTT_STATUS_FAIL_NOT_SCHEDULED_YET; 207 using ::RTT_STATUS_FAIL_PROTOCOL; 208 using ::RTT_STATUS_FAIL_REJECTED; 209 using ::RTT_STATUS_FAIL_SCHEDULE; 210 using ::RTT_STATUS_FAIL_TM_TIMEOUT; 211 using ::RTT_STATUS_FAILURE; 212 using ::RTT_STATUS_INVALID_REQ; 213 using ::RTT_STATUS_NAN_RANGING_CONCURRENCY_NOT_SUPPORTED; 214 using ::RTT_STATUS_NAN_RANGING_PROTOCOL_FAILURE; 215 using ::RTT_STATUS_NO_WIFI; 216 using ::RTT_STATUS_SECURE_RANGING_FAILURE_INVALID_AKM; 217 using ::RTT_STATUS_SECURE_RANGING_FAILURE_INVALID_CIPHER; 218 using ::RTT_STATUS_SECURE_RANGING_FAILURE_INVALID_CONFIG; 219 using ::RTT_STATUS_SECURE_RANGING_FAILURE_REJECTED; 220 using ::RTT_STATUS_SECURE_RANGING_FAILURE_UNKNOWN; 221 using ::RTT_STATUS_SUCCESS; 222 using ::RTT_TYPE_1_SIDED; 223 using ::RTT_TYPE_2_SIDED; 224 using ::RTT_TYPE_2_SIDED_11AZ_NTB; 225 using ::RTT_TYPE_2_SIDED_11AZ_NTB_SECURE; 226 using ::RTT_TYPE_2_SIDED_11MC; 227 using ::RX_PKT_FATE_DRV_DROP_FILTER; 228 using ::RX_PKT_FATE_DRV_DROP_INVALID; 229 using ::RX_PKT_FATE_DRV_DROP_NOBUFS; 230 using ::RX_PKT_FATE_DRV_DROP_OTHER; 231 using ::RX_PKT_FATE_DRV_QUEUED; 232 using ::RX_PKT_FATE_FW_DROP_FILTER; 233 using ::RX_PKT_FATE_FW_DROP_INVALID; 234 using ::RX_PKT_FATE_FW_DROP_NOBUFS; 235 using ::RX_PKT_FATE_FW_DROP_OTHER; 236 using ::RX_PKT_FATE_FW_QUEUED; 237 using ::RX_PKT_FATE_SUCCESS; 238 using ::SAE; 239 using ::ssid_t; 240 using ::transaction_id; 241 using ::TX_PKT_FATE_ACKED; 242 using ::TX_PKT_FATE_DRV_DROP_INVALID; 243 using ::TX_PKT_FATE_DRV_DROP_NOBUFS; 244 using ::TX_PKT_FATE_DRV_DROP_OTHER; 245 using ::TX_PKT_FATE_DRV_QUEUED; 246 using ::TX_PKT_FATE_FW_DROP_INVALID; 247 using ::TX_PKT_FATE_FW_DROP_NOBUFS; 248 using ::TX_PKT_FATE_FW_DROP_OTHER; 249 using ::TX_PKT_FATE_FW_QUEUED; 250 using ::TX_PKT_FATE_SENT; 251 using ::WIFI_AC_BE; 252 using ::WIFI_AC_BK; 253 using ::WIFI_AC_VI; 254 using ::WIFI_AC_VO; 255 using ::WIFI_ANTENNA_1X1; 256 using ::WIFI_ANTENNA_2X2; 257 using ::WIFI_ANTENNA_3X3; 258 using ::WIFI_ANTENNA_4X4; 259 using ::WIFI_ANTENNA_UNSPECIFIED; 260 using ::wifi_band; 261 using ::WIFI_BAND_A; 262 using ::WIFI_BAND_A_DFS; 263 using ::WIFI_BAND_A_WITH_DFS; 264 using ::WIFI_BAND_ABG; 265 using ::WIFI_BAND_ABG_WITH_DFS; 266 using ::WIFI_BAND_BG; 267 using ::WIFI_BAND_UNSPECIFIED; 268 using ::wifi_cached_scan_report; 269 using ::wifi_cached_scan_result; 270 using ::wifi_cached_scan_results; 271 using ::WIFI_CHAN_WIDTH_10; 272 using ::WIFI_CHAN_WIDTH_160; 273 using ::WIFI_CHAN_WIDTH_20; 274 using ::WIFI_CHAN_WIDTH_320; 275 using ::WIFI_CHAN_WIDTH_40; 276 using ::WIFI_CHAN_WIDTH_5; 277 using ::WIFI_CHAN_WIDTH_80; 278 using ::WIFI_CHAN_WIDTH_80P80; 279 using ::WIFI_CHAN_WIDTH_INVALID; 280 using ::wifi_channel_category; 281 using ::wifi_channel_info; 282 using ::wifi_channel_stat; 283 using ::wifi_channel_width; 284 using ::wifi_chip_capabilities; 285 using ::wifi_coex_restriction; 286 using ::wifi_coex_unsafe_channel; 287 using ::WIFI_DFS_CHANNEL; 288 using ::WIFI_DUAL_STA_NON_TRANSIENT_UNBIASED; 289 using ::WIFI_DUAL_STA_TRANSIENT_PREFER_PRIMARY; 290 using ::wifi_error; 291 using ::WIFI_ERROR_BUSY; 292 using ::WIFI_ERROR_INVALID_ARGS; 293 using ::WIFI_ERROR_INVALID_REQUEST_ID; 294 using ::WIFI_ERROR_NONE; 295 using ::WIFI_ERROR_NOT_AVAILABLE; 296 using ::WIFI_ERROR_NOT_SUPPORTED; 297 using ::WIFI_ERROR_OUT_OF_MEMORY; 298 using ::WIFI_ERROR_TIMED_OUT; 299 using ::WIFI_ERROR_TOO_MANY_REQUESTS; 300 using ::WIFI_ERROR_UNINITIALIZED; 301 using ::WIFI_ERROR_UNKNOWN; 302 using ::wifi_gscan_capabilities; 303 using ::wifi_hal_fn; 304 using ::wifi_iface_concurrency_matrix; 305 using ::WIFI_INDOOR_CHANNEL; 306 using ::wifi_information_element; 307 using ::WIFI_INTERFACE_IBSS; 308 using ::WIFI_INTERFACE_MESH; 309 using ::wifi_interface_mode; 310 using ::WIFI_INTERFACE_NAN; 311 using ::WIFI_INTERFACE_P2P_CLIENT; 312 using ::WIFI_INTERFACE_P2P_GO; 313 using ::WIFI_INTERFACE_SOFTAP; 314 using ::WIFI_INTERFACE_STA; 315 using ::WIFI_INTERFACE_TDLS; 316 using ::wifi_interface_type; 317 using ::WIFI_INTERFACE_TYPE_AP; 318 using ::WIFI_INTERFACE_TYPE_NAN; 319 using ::WIFI_INTERFACE_TYPE_P2P; 320 using ::WIFI_INTERFACE_TYPE_STA; 321 using ::WIFI_INTERFACE_UNKNOWN; 322 using ::wifi_latency_mode; 323 using ::WIFI_LATENCY_MODE_LOW; 324 using ::WIFI_LATENCY_MODE_NORMAL; 325 using ::wifi_lci_information; 326 using ::wifi_lcr_information; 327 using ::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED; 328 using ::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED; 329 using ::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED; 330 using ::WIFI_LOGGER_PACKET_FATE_SUPPORTED; 331 using ::WIFI_LOGGER_POWER_EVENT_SUPPORTED; 332 using ::WIFI_LOGGER_WAKE_LOCK_SUPPORTED; 333 using ::wifi_mlo_mode; 334 using ::WIFI_MOTION_EXPECTED; 335 using ::WIFI_MOTION_NOT_EXPECTED; 336 using ::wifi_motion_pattern; 337 using ::WIFI_MOTION_UNKNOWN; 338 using ::wifi_multi_sta_use_case; 339 using ::wifi_power_scenario; 340 using ::WIFI_POWER_SCENARIO_ON_BODY_CELL_OFF; 341 using ::WIFI_POWER_SCENARIO_ON_BODY_CELL_ON; 342 using ::WIFI_POWER_SCENARIO_ON_HEAD_CELL_OFF; 343 using ::WIFI_POWER_SCENARIO_ON_HEAD_CELL_ON; 344 using ::WIFI_POWER_SCENARIO_VOICE_CALL; 345 using ::wifi_radio_combination; 346 using ::wifi_radio_combination_matrix; 347 using ::wifi_radio_configuration; 348 using ::wifi_rate; 349 using ::wifi_request_id; 350 using ::wifi_ring_buffer_status; 351 using ::wifi_roaming_capabilities; 352 using ::wifi_roaming_config; 353 using ::wifi_rtt_akm; 354 using ::wifi_rtt_bw; 355 using ::WIFI_RTT_BW_10; 356 using ::WIFI_RTT_BW_160; 357 using ::WIFI_RTT_BW_20; 358 using ::WIFI_RTT_BW_320; 359 using ::WIFI_RTT_BW_40; 360 using ::WIFI_RTT_BW_5; 361 using ::WIFI_RTT_BW_80; 362 using ::WIFI_RTT_BW_UNSPECIFIED; 363 using ::wifi_rtt_capabilities; 364 using ::wifi_rtt_capabilities_v3; 365 using ::wifi_rtt_capabilities_v4; 366 using ::wifi_rtt_cipher_suite; 367 using ::wifi_rtt_config; 368 using ::wifi_rtt_config_v3; 369 using ::wifi_rtt_config_v4; 370 using ::wifi_rtt_preamble; 371 using ::WIFI_RTT_PREAMBLE_EHT; 372 using ::WIFI_RTT_PREAMBLE_HE; 373 using ::WIFI_RTT_PREAMBLE_HT; 374 using ::WIFI_RTT_PREAMBLE_INVALID; 375 using ::WIFI_RTT_PREAMBLE_LEGACY; 376 using ::WIFI_RTT_PREAMBLE_VHT; 377 using ::wifi_rtt_responder; 378 using ::wifi_rtt_result; 379 using ::wifi_rtt_result_v2; 380 using ::wifi_rtt_result_v3; 381 using ::wifi_rtt_result_v4; 382 using ::wifi_rtt_status; 383 using ::wifi_rtt_type; 384 using ::wifi_rx_packet_fate; 385 using ::wifi_rx_report; 386 using ::wifi_scan_bucket_spec; 387 using ::wifi_scan_cmd_params; 388 using ::WIFI_SCAN_FLAG_INTERRUPTED; 389 using ::wifi_scan_result; 390 using ::WIFI_SUCCESS; 391 using ::wifi_twt_capabilities; 392 using ::wifi_twt_error_code; 393 using ::wifi_twt_events; 394 using ::wifi_twt_request; 395 using ::wifi_twt_session; 396 using ::wifi_twt_session_stats; 397 using ::wifi_twt_teardown_reason_code; 398 using ::wifi_tx_packet_fate; 399 using ::wifi_tx_report; 400 using ::wifi_usable_channel; 401 using ::WIFI_USABLE_CHANNEL_FILTER_CELLULAR_COEXISTENCE; 402 using ::WIFI_USABLE_CHANNEL_FILTER_CONCURRENCY; 403 using ::WLAN_MAC_2_4_BAND; 404 using ::WLAN_MAC_5_0_BAND; 405 using ::WLAN_MAC_60_0_BAND; 406 using ::WLAN_MAC_6_0_BAND; 407 using ::WPA_CIPHER_CCMP_128; 408 using ::WPA_CIPHER_CCMP_256; 409 using ::WPA_CIPHER_GCMP_128; 410 using ::WPA_CIPHER_GCMP_256; 411 using ::WPA_CIPHER_NONE; 412 using ::WPA_KEY_MGMT_EAP_FILS_SHA256; 413 using ::WPA_KEY_MGMT_EAP_FILS_SHA384; 414 using ::WPA_KEY_MGMT_EAP_FT_SHA256; 415 using ::WPA_KEY_MGMT_EAP_FT_SHA384; 416 using ::WPA_KEY_MGMT_FT_PSK_SHA256; 417 using ::WPA_KEY_MGMT_FT_PSK_SHA384; 418 using ::WPA_KEY_MGMT_NONE; 419 using ::WPA_KEY_MGMT_PASN; 420 using ::WPA_KEY_MGMT_SAE; 421 422 // APF capabilities supported by the iface. 423 struct PacketFilterCapabilities { 424 uint32_t version; 425 uint32_t max_len; 426 }; 427 428 // WARNING: We don't care about the variable sized members of either 429 // |wifi_iface_stat|, |wifi_radio_stat| structures. So, using the pragma 430 // to escape the compiler warnings regarding this. 431 #pragma GCC diagnostic push 432 #pragma GCC diagnostic ignored "-Wgnu-variable-sized-type-not-at-end" 433 // The |wifi_radio_stat.tx_time_per_levels| stats is provided as a pointer in 434 // |wifi_radio_stat| structure in the legacy HAL API. Separate that out 435 // into a separate return element to avoid passing pointers around. 436 struct LinkLayerRadioStats { 437 wifi_radio_stat stats; 438 std::vector<uint32_t> tx_time_per_levels; 439 std::vector<wifi_channel_stat> channel_stats; 440 }; 441 442 struct WifiPeerInfo { 443 wifi_peer_info peer_info; 444 std::vector<wifi_rate_stat> rate_stats; 445 }; 446 447 struct LinkLayerStats { 448 wifi_iface_stat iface; 449 std::vector<LinkLayerRadioStats> radios; 450 std::vector<WifiPeerInfo> peers; 451 bool valid; 452 }; 453 454 struct LinkStats { 455 wifi_link_stat stat; 456 std::vector<WifiPeerInfo> peers; 457 }; 458 459 struct LinkLayerMlStats { 460 wifi_iface_ml_stat iface; 461 std::vector<LinkStats> links; 462 std::vector<LinkLayerRadioStats> radios; 463 bool valid; 464 }; 465 466 struct WifiCachedScanReport { 467 uint64_t ts; 468 std::vector<int> scanned_freqs; 469 std::vector<wifi_cached_scan_result> results; 470 }; 471 472 #pragma GCC diagnostic pop 473 474 // The |WLAN_DRIVER_WAKE_REASON_CNT.cmd_event_wake_cnt| and 475 // |WLAN_DRIVER_WAKE_REASON_CNT.driver_fw_local_wake_cnt| stats is provided 476 // as a pointer in |WLAN_DRIVER_WAKE_REASON_CNT| structure in the legacy HAL 477 // API. Separate that out into a separate return elements to avoid passing 478 // pointers around. 479 struct WakeReasonStats { 480 WLAN_DRIVER_WAKE_REASON_CNT wake_reason_cnt; 481 std::vector<uint32_t> cmd_event_wake_cnt; 482 std::vector<uint32_t> driver_fw_local_wake_cnt; 483 }; 484 485 // NAN response and event callbacks struct. 486 struct NanCallbackHandlers { 487 // NotifyResponse invoked to notify the status of the Request. 488 std::function<void(transaction_id, const NanResponseMsg&)> on_notify_response; 489 // Various event callbacks. 490 std::function<void(const NanPublishTerminatedInd&)> on_event_publish_terminated; 491 std::function<void(const NanMatchInd&)> on_event_match; 492 std::function<void(const NanMatchExpiredInd&)> on_event_match_expired; 493 std::function<void(const NanSubscribeTerminatedInd&)> on_event_subscribe_terminated; 494 std::function<void(const NanFollowupInd&)> on_event_followup; 495 std::function<void(const NanDiscEngEventInd&)> on_event_disc_eng_event; 496 std::function<void(const NanDisabledInd&)> on_event_disabled; 497 std::function<void(const NanTCAInd&)> on_event_tca; 498 std::function<void(const NanBeaconSdfPayloadInd&)> on_event_beacon_sdf_payload; 499 std::function<void(const NanDataPathRequestInd&)> on_event_data_path_request; 500 std::function<void(const NanDataPathConfirmInd&)> on_event_data_path_confirm; 501 std::function<void(const NanDataPathEndInd&)> on_event_data_path_end; 502 std::function<void(const NanTransmitFollowupInd&)> on_event_transmit_follow_up; 503 std::function<void(const NanRangeRequestInd&)> on_event_range_request; 504 std::function<void(const NanRangeReportInd&)> on_event_range_report; 505 std::function<void(const NanDataPathScheduleUpdateInd&)> on_event_schedule_update; 506 std::function<void(const NanPairingRequestInd&)> on_event_pairing_request; 507 std::function<void(const NanPairingConfirmInd&)> on_event_pairing_confirm; 508 std::function<void(const NanBootstrappingRequestInd&)> on_event_bootstrapping_request; 509 std::function<void(const NanBootstrappingConfirmInd&)> on_event_bootstrapping_confirm; 510 std::function<void(const NanSuspensionModeChangeInd&)> on_event_suspension_mode_change; 511 std::function<void(wifi_rtt_result* rtt_results[], uint32_t num_results, uint16_t session_id)> 512 on_ranging_results; 513 }; 514 515 // Full scan results contain IE info and are hence passed by reference, to 516 // preserve the variable length array member |ie_data|. Callee must not retain 517 // the pointer. 518 using on_gscan_full_result_callback = 519 std::function<void(wifi_request_id, const wifi_scan_result*, uint32_t)>; 520 // These scan results don't contain any IE info, so no need to pass by 521 // reference. 522 using on_gscan_results_callback = 523 std::function<void(wifi_request_id, const std::vector<wifi_cached_scan_results>&)>; 524 525 // Invoked when the rssi value breaches the thresholds set. 526 using on_rssi_threshold_breached_callback = 527 std::function<void(wifi_request_id, std::array<uint8_t, ETH_ALEN>, int8_t)>; 528 529 // Callback for RTT range request results. 530 // Rtt results contain IE info and are hence passed by reference, to 531 // preserve the |LCI| and |LCR| pointers. Callee must not retain 532 // the pointer. 533 using on_rtt_results_callback = 534 std::function<void(wifi_request_id, const std::vector<const wifi_rtt_result*>&)>; 535 using on_rtt_results_callback_v2 = 536 std::function<void(wifi_request_id, const std::vector<const wifi_rtt_result_v2*>&)>; 537 using on_rtt_results_callback_v3 = 538 std::function<void(wifi_request_id, const std::vector<const wifi_rtt_result_v3*>&)>; 539 using on_rtt_results_callback_v4 = 540 std::function<void(wifi_request_id, const std::vector<const wifi_rtt_result_v4*>&)>; 541 542 // Callback for ring buffer data. 543 using on_ring_buffer_data_callback = std::function<void( 544 const std::string&, const std::vector<uint8_t>&, const wifi_ring_buffer_status&)>; 545 546 // Callback for alerts. 547 using on_error_alert_callback = std::function<void(int32_t, const std::vector<uint8_t>&)>; 548 549 // Callback for subsystem restart 550 using on_subsystem_restart_callback = std::function<void(const std::string&)>; 551 552 // Struct for the mac info from the legacy HAL. This is a cleaner version 553 // of the |wifi_mac_info| & |wifi_iface_info|. 554 typedef struct { 555 std::string name; 556 wifi_channel channel; 557 } WifiIfaceInfo; 558 559 typedef struct { 560 uint32_t wlan_mac_id; 561 /* BIT MASK of BIT(WLAN_MAC*) as represented by wlan_mac_band */ 562 uint32_t mac_band; 563 /* Represents the connected Wi-Fi interfaces associated with each MAC */ 564 std::vector<WifiIfaceInfo> iface_infos; 565 } WifiMacInfo; 566 567 // Callback for radio mode change 568 using on_radio_mode_change_callback = std::function<void(const std::vector<WifiMacInfo>&)>; 569 570 // TWT response and event callbacks struct. 571 struct TwtCallbackHandlers { 572 // Callback for TWT setup response 573 std::function<void(const TwtSetupResponse&)> on_setup_response; 574 // Callback for TWT teardown completion 575 std::function<void(const TwtTeardownCompletion&)> on_teardown_completion; 576 // Callback for TWT info frame received event 577 std::function<void(const TwtInfoFrameReceived&)> on_info_frame_received; 578 // Callback for TWT notification from the device 579 std::function<void(const TwtDeviceNotify&)> on_device_notify; 580 }; 581 582 // CHRE response and event callbacks struct. 583 struct ChreCallbackHandlers { 584 // Callback for CHRE NAN RTT 585 std::function<void(chre_nan_rtt_state)> on_wifi_chre_nan_rtt_state; 586 }; 587 588 using on_cached_scan_results_callback = std::function<void(wifi_cached_scan_report*)>; 589 590 struct CachedScanResultsCallbfackHandlers { 591 // Callback for Cached Scan Results 592 std::function<void(wifi_cached_scan_report*)> on_cached_scan_results; 593 }; 594 595 using on_twt_failure = std::function<void(wifi_request_id id, wifi_twt_error_code error_code)>; 596 using on_twt_session_create = std::function<void(wifi_request_id id, wifi_twt_session twt_session)>; 597 using on_twt_session_update = std::function<void(wifi_request_id id, wifi_twt_session twt_session)>; 598 using on_twt_session_teardown = std::function<void(wifi_request_id id, int session_id, 599 wifi_twt_teardown_reason_code reason_code)>; 600 using on_twt_session_stats = 601 std::function<void(wifi_request_id id, int session_id, wifi_twt_session_stats stats)>; 602 using on_twt_session_suspend = std::function<void(wifi_request_id id, int session_id)>; 603 using on_twt_session_resume = std::function<void(wifi_request_id id, int session_id)>; 604 605 /** 606 * Class that encapsulates all legacy HAL interactions. 607 * This class manages the lifetime of the event loop thread used by legacy HAL. 608 * 609 * Note: There will only be a single instance of this class created in the Wifi 610 * object and will be valid for the lifetime of the process. 611 */ 612 class WifiLegacyHal { 613 public: 614 WifiLegacyHal(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool, 615 const wifi_hal_fn& fn, bool is_primary); 616 virtual ~WifiLegacyHal() = default; 617 618 // Initialize the legacy HAL function table. 619 virtual wifi_error initialize(); 620 // Start the legacy HAL and the event looper thread. 621 virtual wifi_error start(); 622 // Deinitialize the legacy HAL and wait for the event loop thread to exit 623 // using a predefined timeout. 624 virtual wifi_error stop(std::unique_lock<std::recursive_mutex>* lock, 625 const std::function<void()>& on_complete_callback); 626 virtual wifi_error waitForDriverReady(); 627 // Checks if legacy HAL has successfully started 628 bool isStarted(); 629 // Wrappers for all the functions in the legacy HAL function table. 630 virtual std::pair<wifi_error, std::string> getDriverVersion(const std::string& iface_name); 631 virtual std::pair<wifi_error, std::string> getFirmwareVersion(const std::string& iface_name); 632 std::pair<wifi_error, std::vector<uint8_t>> requestDriverMemoryDump( 633 const std::string& iface_name); 634 std::pair<wifi_error, std::vector<uint8_t>> requestFirmwareMemoryDump( 635 const std::string& iface_name); 636 virtual std::pair<wifi_error, uint64_t> getSupportedFeatureSet(const std::string& iface_name); 637 // APF functions. 638 std::pair<wifi_error, PacketFilterCapabilities> getPacketFilterCapabilities( 639 const std::string& iface_name); 640 wifi_error setPacketFilter(const std::string& iface_name, const std::vector<uint8_t>& program); 641 std::pair<wifi_error, std::vector<uint8_t>> readApfPacketFilterData( 642 const std::string& iface_name); 643 // Gscan functions. 644 std::pair<wifi_error, wifi_gscan_capabilities> getGscanCapabilities( 645 const std::string& iface_name); 646 // These API's provides a simplified interface over the legacy Gscan API's: 647 // a) All scan events from the legacy HAL API other than the 648 // |WIFI_SCAN_FAILED| are treated as notification of results. 649 // This method then retrieves the cached scan results from the legacy 650 // HAL API and triggers the externally provided 651 // |on_results_user_callback| on success. 652 // b) |WIFI_SCAN_FAILED| scan event or failure to retrieve cached scan 653 // results 654 // Triggers the externally provided |on_failure_user_callback|. 655 // c) Full scan result event triggers the externally provided 656 // |on_full_result_user_callback|. 657 wifi_error startGscan(const std::string& iface_name, wifi_request_id id, 658 const wifi_scan_cmd_params& params, 659 const std::function<void(wifi_request_id)>& on_failure_callback, 660 const on_gscan_results_callback& on_results_callback, 661 const on_gscan_full_result_callback& on_full_result_callback); 662 wifi_error stopGscan(const std::string& iface_name, wifi_request_id id); 663 std::pair<wifi_error, std::vector<uint32_t>> getValidFrequenciesForBand( 664 const std::string& iface_name, wifi_band band); 665 virtual wifi_error setDfsFlag(const std::string& iface_name, bool dfs_on); 666 // Link layer stats functions. 667 wifi_error enableLinkLayerStats(const std::string& iface_name, bool debug); 668 wifi_error disableLinkLayerStats(const std::string& iface_name); 669 wifi_error getLinkLayerStats(const std::string& iface_name, 670 legacy_hal::LinkLayerStats& legacy_stats, 671 legacy_hal::LinkLayerMlStats& legacy_ml_stats); 672 // RSSI monitor functions. 673 wifi_error startRssiMonitoring( 674 const std::string& iface_name, wifi_request_id id, int8_t max_rssi, int8_t min_rssi, 675 const on_rssi_threshold_breached_callback& on_threshold_breached_callback); 676 wifi_error stopRssiMonitoring(const std::string& iface_name, wifi_request_id id); 677 std::pair<wifi_error, wifi_roaming_capabilities> getRoamingCapabilities( 678 const std::string& iface_name); 679 wifi_error configureRoaming(const std::string& iface_name, const wifi_roaming_config& config); 680 wifi_error enableFirmwareRoaming(const std::string& iface_name, fw_roaming_state_t state); 681 wifi_error configureNdOffload(const std::string& iface_name, bool enable); 682 wifi_error startSendingOffloadedPacket(const std::string& iface_name, int32_t cmd_id, 683 uint16_t ether_type, 684 const std::vector<uint8_t>& ip_packet_data, 685 const std::array<uint8_t, 6>& src_address, 686 const std::array<uint8_t, 6>& dst_address, 687 int32_t period_in_ms); 688 wifi_error stopSendingOffloadedPacket(const std::string& iface_name, uint32_t cmd_id); 689 virtual wifi_error selectTxPowerScenario(const std::string& iface_name, 690 wifi_power_scenario scenario); 691 virtual wifi_error resetTxPowerScenario(const std::string& iface_name); 692 wifi_error setLatencyMode(const std::string& iface_name, wifi_latency_mode mode); 693 wifi_error setThermalMitigationMode(wifi_thermal_mode mode, uint32_t completion_window); 694 wifi_error setDscpToAccessCategoryMapping(uint32_t start, uint32_t end, 695 uint32_t access_category); 696 wifi_error resetDscpToAccessCategoryMapping(); 697 // Logger/debug functions. 698 std::pair<wifi_error, uint32_t> getLoggerSupportedFeatureSet(const std::string& iface_name); 699 wifi_error startPktFateMonitoring(const std::string& iface_name); 700 std::pair<wifi_error, std::vector<wifi_tx_report>> getTxPktFates(const std::string& iface_name); 701 std::pair<wifi_error, std::vector<wifi_rx_report>> getRxPktFates(const std::string& iface_name); 702 std::pair<wifi_error, WakeReasonStats> getWakeReasonStats(const std::string& iface_name); 703 wifi_error registerRingBufferCallbackHandler( 704 const std::string& iface_name, const on_ring_buffer_data_callback& on_data_callback); 705 wifi_error deregisterRingBufferCallbackHandler(const std::string& iface_name); 706 virtual wifi_error registerSubsystemRestartCallbackHandler( 707 const on_subsystem_restart_callback& on_restart_callback); 708 std::pair<wifi_error, std::vector<wifi_ring_buffer_status>> getRingBuffersStatus( 709 const std::string& iface_name); 710 wifi_error startRingBufferLogging(const std::string& iface_name, const std::string& ring_name, 711 uint32_t verbose_level, uint32_t max_interval_sec, 712 uint32_t min_data_size); 713 wifi_error getRingBufferData(const std::string& iface_name, const std::string& ring_name); 714 wifi_error registerErrorAlertCallbackHandler(const std::string& iface_name, 715 const on_error_alert_callback& on_alert_callback); 716 wifi_error deregisterErrorAlertCallbackHandler(const std::string& iface_name); 717 // Radio mode functions. 718 virtual wifi_error registerRadioModeChangeCallbackHandler( 719 const std::string& iface_name, 720 const on_radio_mode_change_callback& on_user_change_callback); 721 // RTT functions. 722 wifi_error startRttRangeRequest(const std::string& iface_name, wifi_request_id id, 723 const std::vector<wifi_rtt_config>& rtt_configs, 724 const on_rtt_results_callback& on_results_callback, 725 const on_rtt_results_callback_v2& on_results_callback_v2); 726 wifi_error startRttRangeRequestV3(const std::string& iface_name, wifi_request_id id, 727 const std::vector<wifi_rtt_config_v3>& rtt_configs, 728 const on_rtt_results_callback_v3& on_results_callback); 729 wifi_error startRttRangeRequestV4(const std::string& iface_name, wifi_request_id id, 730 const std::vector<wifi_rtt_config_v4>& rtt_configs, 731 const on_rtt_results_callback_v4& on_results_callback); 732 733 wifi_error cancelRttRangeRequest(const std::string& iface_name, wifi_request_id id, 734 const std::vector<std::array<uint8_t, ETH_ALEN>>& mac_addrs); 735 std::pair<wifi_error, wifi_rtt_capabilities> getRttCapabilities(const std::string& iface_name); 736 std::pair<wifi_error, wifi_rtt_capabilities_v3> getRttCapabilitiesV3( 737 const std::string& iface_name); 738 std::pair<wifi_error, wifi_rtt_capabilities_v4> getRttCapabilitiesV4( 739 const std::string& iface_name); 740 std::pair<wifi_error, wifi_rtt_responder> getRttResponderInfo(const std::string& iface_name); 741 wifi_error enableRttResponder(const std::string& iface_name, wifi_request_id id, 742 const wifi_channel_info& channel_hint, uint32_t max_duration_secs, 743 const wifi_rtt_responder& info); 744 wifi_error disableRttResponder(const std::string& iface_name, wifi_request_id id); 745 wifi_error setRttLci(const std::string& iface_name, wifi_request_id id, 746 const wifi_lci_information& info); 747 wifi_error setRttLcr(const std::string& iface_name, wifi_request_id id, 748 const wifi_lcr_information& info); 749 // NAN functions. 750 virtual wifi_error nanRegisterCallbackHandlers(const std::string& iface_name, 751 const NanCallbackHandlers& callbacks); 752 wifi_error nanEnableRequest(const std::string& iface_name, transaction_id id, 753 const NanEnableRequest& msg); 754 virtual wifi_error nanDisableRequest(const std::string& iface_name, transaction_id id); 755 wifi_error nanPublishRequest(const std::string& iface_name, transaction_id id, 756 const NanPublishRequest& msg); 757 wifi_error nanPublishCancelRequest(const std::string& iface_name, transaction_id id, 758 const NanPublishCancelRequest& msg); 759 wifi_error nanSubscribeRequest(const std::string& iface_name, transaction_id id, 760 const NanSubscribeRequest& msg); 761 wifi_error nanSubscribeCancelRequest(const std::string& iface_name, transaction_id id, 762 const NanSubscribeCancelRequest& msg); 763 wifi_error nanTransmitFollowupRequest(const std::string& iface_name, transaction_id id, 764 const NanTransmitFollowupRequest& msg); 765 wifi_error nanStatsRequest(const std::string& iface_name, transaction_id id, 766 const NanStatsRequest& msg); 767 wifi_error nanConfigRequest(const std::string& iface_name, transaction_id id, 768 const NanConfigRequest& msg); 769 wifi_error nanTcaRequest(const std::string& iface_name, transaction_id id, 770 const NanTCARequest& msg); 771 wifi_error nanBeaconSdfPayloadRequest(const std::string& iface_name, transaction_id id, 772 const NanBeaconSdfPayloadRequest& msg); 773 std::pair<wifi_error, NanVersion> nanGetVersion(); 774 wifi_error nanGetCapabilities(const std::string& iface_name, transaction_id id); 775 wifi_error nanDataInterfaceCreate(const std::string& iface_name, transaction_id id, 776 const std::string& data_iface_name); 777 virtual wifi_error nanDataInterfaceDelete(const std::string& iface_name, transaction_id id, 778 const std::string& data_iface_name); 779 wifi_error nanDataRequestInitiator(const std::string& iface_name, transaction_id id, 780 const NanDataPathInitiatorRequest& msg); 781 wifi_error nanDataIndicationResponse(const std::string& iface_name, transaction_id id, 782 const NanDataPathIndicationResponse& msg); 783 wifi_error nanPairingRequest(const std::string& iface_name, transaction_id id, 784 const NanPairingRequest& msg); 785 wifi_error nanPairingIndicationResponse(const std::string& iface_name, transaction_id id, 786 const NanPairingIndicationResponse& msg); 787 wifi_error nanBootstrappingRequest(const std::string& iface_name, transaction_id id, 788 const NanBootstrappingRequest& msg); 789 wifi_error nanBootstrappingIndicationResponse(const std::string& iface_name, transaction_id id, 790 const NanBootstrappingIndicationResponse& msg); 791 wifi_error nanDataEnd(const std::string& iface_name, transaction_id id, uint32_t ndpInstanceId); 792 wifi_error nanPairingEnd(const std::string& iface_name, transaction_id id, uint32_t pairingId); 793 wifi_error nanSuspendRequest(const std::string& iface_name, transaction_id id, 794 const NanSuspendRequest& msg); 795 wifi_error nanResumeRequest(const std::string& iface_name, transaction_id id, 796 const NanResumeRequest& msg); 797 // AP functions. 798 wifi_error setCountryCode(const std::string& iface_name, const std::array<uint8_t, 2> code); 799 800 // Interface functions. 801 virtual wifi_error createVirtualInterface(const std::string& ifname, 802 wifi_interface_type iftype); 803 virtual wifi_error deleteVirtualInterface(const std::string& ifname); 804 virtual wifi_error getSupportedIfaceName(uint32_t iface_type, std::string& ifname); 805 806 // STA + STA functions 807 virtual wifi_error multiStaSetPrimaryConnection(const std::string& ifname); 808 virtual wifi_error multiStaSetUseCase(wifi_multi_sta_use_case use_case); 809 810 // Coex functions. 811 virtual wifi_error setCoexUnsafeChannels(std::vector<wifi_coex_unsafe_channel> unsafe_channels, 812 uint32_t restrictions); 813 814 wifi_error setVoipMode(const std::string& iface_name, wifi_voip_mode mode); 815 816 // TWT functions 817 std::pair<wifi_twt_capabilities, wifi_error> twtGetCapabilities(const std::string& ifaceName); 818 wifi_error twtRegisterEvents( 819 const std::string& ifaceName, const on_twt_failure& on_twt_failure_user_callback, 820 const on_twt_session_create& on_twt_session_create_user_callback, 821 const on_twt_session_update& on_twt_session_update_user_callback, 822 const on_twt_session_teardown& on_twt_session_teardown_user_callback, 823 const on_twt_session_stats& on_twt_session_stats_user_callback, 824 const on_twt_session_suspend& on_twt_session_suspend_user_callback, 825 const on_twt_session_resume& on_twt_session_resume_user_callback); 826 wifi_error twtSessionSetup(const std::string& ifaceName, uint32_t cmdId, 827 const wifi_twt_request& request); 828 wifi_error twtSessionUpdate(const std::string& ifaceName, uint32_t cmdId, uint32_t sessionId, 829 const wifi_twt_request& request); 830 wifi_error twtSessionSuspend(const std::string& ifaceName, uint32_t cmdId, uint32_t sessionId); 831 wifi_error twtSessionResume(const std::string& ifaceName, uint32_t cmdId, uint32_t sessionId); 832 wifi_error twtSessionTeardown(const std::string& ifaceName, uint32_t cmdId, uint32_t sessionId); 833 wifi_error twtSessionGetStats(const std::string& ifaceName, uint32_t cmdId, uint32_t sessionId); 834 835 // Note: Following TWT functions are deprecated 836 // Deprecated by twtRegisterEvegnts 837 wifi_error twtRegisterHandler(const std::string& iface_name, 838 const TwtCallbackHandlers& handler); 839 // Deprecated by twtGetCapabilities 840 std::pair<wifi_error, TwtCapabilitySet> twtGetCapability(const std::string& iface_name); 841 // Deprecated by twtSessionSetup 842 wifi_error twtSetupRequest(const std::string& iface_name, const TwtSetupRequest& msg); 843 // Deprecated by twtSessionTeardown 844 wifi_error twtTearDownRequest(const std::string& iface_name, const TwtTeardownRequest& msg); 845 // Deprecated by twtSessionSuspend and twtSessionResume 846 wifi_error twtInfoFrameRequest(const std::string& iface_name, const TwtInfoFrameRequest& msg); 847 // Deprecated by twtSessionGetStats 848 std::pair<wifi_error, TwtStats> twtGetStats(const std::string& iface_name, uint8_t configId); 849 // Deprecated 850 wifi_error twtClearStats(const std::string& iface_name, uint8_t configId); 851 852 wifi_error setScanMode(const std::string& iface_name, bool enable); 853 854 wifi_error setDtimConfig(const std::string& iface_name, uint32_t multiplier); 855 856 // Retrieve the list of usable channels in the requested bands 857 // for the requested modes 858 std::pair<wifi_error, std::vector<wifi_usable_channel>> getUsableChannels( 859 uint32_t band_mask, uint32_t iface_mode_mask, uint32_t filter_mask); 860 861 wifi_error triggerSubsystemRestart(); 862 863 wifi_error setIndoorState(bool isIndoor); 864 865 std::pair<wifi_error, wifi_radio_combination_matrix*> getSupportedRadioCombinationsMatrix(); 866 867 // CHRE NAN RTT function 868 wifi_error chreNanRttRequest(const std::string& iface_name, bool enable); 869 870 wifi_error chreRegisterHandler(const std::string& iface_name, 871 const ChreCallbackHandlers& handler); 872 873 wifi_error enableWifiTxPowerLimits(const std::string& iface_name, bool enable); 874 wifi_error getWifiCachedScanResults(const std::string& iface_name, 875 WifiCachedScanReport& report); 876 std::pair<wifi_error, wifi_chip_capabilities> getWifiChipCapabilities(); 877 wifi_error enableStaChannelForPeerNetwork(uint32_t channelCategoryEnableFlag); 878 wifi_error setMloMode(wifi_mlo_mode mode); 879 std::pair<wifi_error, wifi_iface_concurrency_matrix> getSupportedIfaceConcurrencyMatrix(); 880 881 private: 882 // Retrieve interface handles for all the available interfaces. 883 wifi_error retrieveIfaceHandles(); 884 wifi_interface_handle getIfaceHandle(const std::string& iface_name); 885 // Run the legacy HAL event loop thread. 886 void runEventLoop(); 887 // Retrieve the cached gscan results to pass the results back to the 888 // external callbacks. 889 std::pair<wifi_error, std::vector<wifi_cached_scan_results>> getGscanCachedResults( 890 const std::string& iface_name); 891 void invalidate(); 892 // Handles wifi (error) status of Virtual interface create/delete 893 wifi_error handleVirtualInterfaceCreateOrDeleteStatus(const std::string& ifname, 894 wifi_error status); 895 wifi_link_stat* copyLinkStat(wifi_link_stat* stat_ptr, std::vector<LinkStats>& stats); 896 wifi_peer_info* copyPeerInfo(wifi_peer_info* peer_ptr, std::vector<WifiPeerInfo>& peers); 897 898 // Global function table of legacy HAL. 899 wifi_hal_fn global_func_table_; 900 // Opaque handle to be used for all global operations. 901 wifi_handle global_handle_; 902 // Map of interface name to handle that is to be used for all interface 903 // specific operations. 904 std::map<std::string, wifi_interface_handle> iface_name_to_handle_; 905 // Flag to indicate if we have initiated the cleanup of legacy HAL. 906 std::atomic<bool> awaiting_event_loop_termination_; 907 std::condition_variable_any stop_wait_cv_; 908 // Flag to indicate if the legacy HAL has been started. 909 bool is_started_; 910 std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool_; 911 // Flag to indicate if this HAL is for the primary chip. This is used 912 // in order to avoid some hard-coded behavior used with older HALs, 913 // such as bring wlan0 interface up/down on start/stop HAL. 914 // it may be removed once vendor HALs are updated. 915 bool is_primary_; 916 }; 917 918 } // namespace legacy_hal 919 } // namespace wifi 920 } // namespace hardware 921 } // namespace android 922 } // namespace aidl 923 924 #endif // WIFI_LEGACY_HAL_H_ 925