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