Roshan Pius | 3c4e8a3 | 2016-10-03 14:53:58 -0700 | [diff] [blame] | 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_CHIP_H_ |
| 18 | #define WIFI_CHIP_H_ |
| 19 | |
xshu | 5899e8e | 2018-01-09 15:36:03 -0800 | [diff] [blame] | 20 | #include <list> |
Roshan Pius | 35d958c | 2016-10-06 16:47:38 -0700 | [diff] [blame] | 21 | #include <map> |
Roshan Pius | 3c4e8a3 | 2016-10-03 14:53:58 -0700 | [diff] [blame] | 22 | |
Roshan Pius | 3c4e8a3 | 2016-10-03 14:53:58 -0700 | [diff] [blame] | 23 | #include <android-base/macros.h> |
Ahmed ElArabawy | eeb5338 | 2019-10-10 20:18:31 -0700 | [diff] [blame] | 24 | #include <android/hardware/wifi/1.4/IWifiChip.h> |
| 25 | #include <android/hardware/wifi/1.4/IWifiRttController.h> |
Roshan Pius | 3c4e8a3 | 2016-10-03 14:53:58 -0700 | [diff] [blame] | 26 | |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 27 | #include "hidl_callback_util.h" |
xshu | 5899e8e | 2018-01-09 15:36:03 -0800 | [diff] [blame] | 28 | #include "ringbuffer.h" |
Roshan Pius | 35d958c | 2016-10-06 16:47:38 -0700 | [diff] [blame] | 29 | #include "wifi_ap_iface.h" |
Roshan Pius | 200a17d | 2017-11-01 13:03:35 -0700 | [diff] [blame] | 30 | #include "wifi_feature_flags.h" |
Roshan Pius | aabe575 | 2016-09-29 09:03:59 -0700 | [diff] [blame] | 31 | #include "wifi_legacy_hal.h" |
Roshan Pius | 52947fb | 2016-11-18 11:38:07 -0800 | [diff] [blame] | 32 | #include "wifi_mode_controller.h" |
Roshan Pius | 35d958c | 2016-10-06 16:47:38 -0700 | [diff] [blame] | 33 | #include "wifi_nan_iface.h" |
| 34 | #include "wifi_p2p_iface.h" |
Roshan Pius | 5926828 | 2016-10-06 20:23:47 -0700 | [diff] [blame] | 35 | #include "wifi_rtt_controller.h" |
Roshan Pius | 35d958c | 2016-10-06 16:47:38 -0700 | [diff] [blame] | 36 | #include "wifi_sta_iface.h" |
Roshan Pius | 3c4e8a3 | 2016-10-03 14:53:58 -0700 | [diff] [blame] | 37 | |
| 38 | namespace android { |
| 39 | namespace hardware { |
| 40 | namespace wifi { |
Ahmed ElArabawy | f501a98 | 2019-07-23 15:02:22 -0700 | [diff] [blame] | 41 | namespace V1_4 { |
Roshan Pius | 79a9975 | 2016-10-04 13:03:58 -0700 | [diff] [blame] | 42 | namespace implementation { |
Roshan Pius | dbd83ef | 2017-06-20 12:05:40 -0700 | [diff] [blame] | 43 | using namespace android::hardware::wifi::V1_0; |
Roshan Pius | 3c4e8a3 | 2016-10-03 14:53:58 -0700 | [diff] [blame] | 44 | |
Roshan Pius | aabe575 | 2016-09-29 09:03:59 -0700 | [diff] [blame] | 45 | /** |
| 46 | * HIDL interface object used to control a Wifi HAL chip instance. |
| 47 | * Since there is only a single chip instance used today, there is no |
| 48 | * identifying handle information stored here. |
| 49 | */ |
Ahmed ElArabawy | eeb5338 | 2019-10-10 20:18:31 -0700 | [diff] [blame] | 50 | class WifiChip : public V1_4::IWifiChip { |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 51 | public: |
Roshan Pius | 200a17d | 2017-11-01 13:03:35 -0700 | [diff] [blame] | 52 | WifiChip( |
| 53 | ChipId chip_id, |
| 54 | const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal, |
| 55 | const std::weak_ptr<mode_controller::WifiModeController> |
| 56 | mode_controller, |
Roshan Pius | 99dab38 | 2019-02-14 07:57:10 -0800 | [diff] [blame] | 57 | const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util, |
Roshan Pius | 200a17d | 2017-11-01 13:03:35 -0700 | [diff] [blame] | 58 | const std::weak_ptr<feature_flags::WifiFeatureFlags> feature_flags); |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 59 | // HIDL does not provide a built-in mechanism to let the server invalidate |
| 60 | // a HIDL interface object after creation. If any client process holds onto |
| 61 | // a reference to the object in their context, any method calls on that |
| 62 | // reference will continue to be directed to the server. |
| 63 | // |
| 64 | // However Wifi HAL needs to control the lifetime of these objects. So, add |
| 65 | // a public |invalidate| method to |WifiChip| and it's child objects. This |
| 66 | // will be used to mark an object invalid when either: |
| 67 | // a) Wifi HAL is stopped, or |
| 68 | // b) Wifi Chip is reconfigured. |
| 69 | // |
| 70 | // All HIDL method implementations should check if the object is still |
| 71 | // marked valid before processing them. |
| 72 | void invalidate(); |
| 73 | bool isValid(); |
Ahmed ElArabawy | fd809fc | 2019-11-15 18:19:15 -0800 | [diff] [blame] | 74 | std::set<sp<IWifiChipEventCallback>> getEventCallbacks(); |
Roshan Pius | 3c4e8a3 | 2016-10-03 14:53:58 -0700 | [diff] [blame] | 75 | |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 76 | // HIDL methods exposed. |
| 77 | Return<void> getId(getId_cb hidl_status_cb) override; |
Jong Wook Kim | da830c9 | 2018-07-23 15:29:38 -0700 | [diff] [blame] | 78 | // Deprecated support for this callback |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 79 | Return<void> registerEventCallback( |
Roshan Pius | 1ce92cf | 2018-01-22 16:12:19 -0800 | [diff] [blame] | 80 | const sp<V1_0::IWifiChipEventCallback>& event_callback, |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 81 | registerEventCallback_cb hidl_status_cb) override; |
| 82 | Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override; |
| 83 | Return<void> getAvailableModes( |
| 84 | getAvailableModes_cb hidl_status_cb) override; |
| 85 | Return<void> configureChip(ChipModeId mode_id, |
| 86 | configureChip_cb hidl_status_cb) override; |
| 87 | Return<void> getMode(getMode_cb hidl_status_cb) override; |
| 88 | Return<void> requestChipDebugInfo( |
| 89 | requestChipDebugInfo_cb hidl_status_cb) override; |
| 90 | Return<void> requestDriverDebugDump( |
| 91 | requestDriverDebugDump_cb hidl_status_cb) override; |
| 92 | Return<void> requestFirmwareDebugDump( |
| 93 | requestFirmwareDebugDump_cb hidl_status_cb) override; |
| 94 | Return<void> createApIface(createApIface_cb hidl_status_cb) override; |
| 95 | Return<void> getApIfaceNames(getApIfaceNames_cb hidl_status_cb) override; |
| 96 | Return<void> getApIface(const hidl_string& ifname, |
| 97 | getApIface_cb hidl_status_cb) override; |
| 98 | Return<void> removeApIface(const hidl_string& ifname, |
| 99 | removeApIface_cb hidl_status_cb) override; |
| 100 | Return<void> createNanIface(createNanIface_cb hidl_status_cb) override; |
| 101 | Return<void> getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) override; |
| 102 | Return<void> getNanIface(const hidl_string& ifname, |
| 103 | getNanIface_cb hidl_status_cb) override; |
| 104 | Return<void> removeNanIface(const hidl_string& ifname, |
| 105 | removeNanIface_cb hidl_status_cb) override; |
| 106 | Return<void> createP2pIface(createP2pIface_cb hidl_status_cb) override; |
| 107 | Return<void> getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) override; |
| 108 | Return<void> getP2pIface(const hidl_string& ifname, |
| 109 | getP2pIface_cb hidl_status_cb) override; |
| 110 | Return<void> removeP2pIface(const hidl_string& ifname, |
| 111 | removeP2pIface_cb hidl_status_cb) override; |
| 112 | Return<void> createStaIface(createStaIface_cb hidl_status_cb) override; |
| 113 | Return<void> getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) override; |
| 114 | Return<void> getStaIface(const hidl_string& ifname, |
| 115 | getStaIface_cb hidl_status_cb) override; |
| 116 | Return<void> removeStaIface(const hidl_string& ifname, |
| 117 | removeStaIface_cb hidl_status_cb) override; |
| 118 | Return<void> createRttController( |
| 119 | const sp<IWifiIface>& bound_iface, |
| 120 | createRttController_cb hidl_status_cb) override; |
| 121 | Return<void> getDebugRingBuffersStatus( |
| 122 | getDebugRingBuffersStatus_cb hidl_status_cb) override; |
| 123 | Return<void> startLoggingToDebugRingBuffer( |
| 124 | const hidl_string& ring_name, |
| 125 | WifiDebugRingBufferVerboseLevel verbose_level, |
| 126 | uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes, |
| 127 | startLoggingToDebugRingBuffer_cb hidl_status_cb) override; |
| 128 | Return<void> forceDumpToDebugRingBuffer( |
| 129 | const hidl_string& ring_name, |
| 130 | forceDumpToDebugRingBuffer_cb hidl_status_cb) override; |
Roger Wang | b294c76 | 2018-11-02 15:34:39 +0800 | [diff] [blame] | 131 | Return<void> flushRingBufferToFile( |
| 132 | flushRingBufferToFile_cb hidl_status_cb) override; |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 133 | Return<void> stopLoggingToDebugRingBuffer( |
| 134 | stopLoggingToDebugRingBuffer_cb hidl_status_cb) override; |
| 135 | Return<void> getDebugHostWakeReasonStats( |
| 136 | getDebugHostWakeReasonStats_cb hidl_status_cb) override; |
| 137 | Return<void> enableDebugErrorAlerts( |
| 138 | bool enable, enableDebugErrorAlerts_cb hidl_status_cb) override; |
| 139 | Return<void> selectTxPowerScenario( |
Ahmed ElArabawy | 6a1accf | 2018-01-23 10:57:29 -0800 | [diff] [blame] | 140 | V1_1::IWifiChip::TxPowerScenario scenario, |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 141 | selectTxPowerScenario_cb hidl_status_cb) override; |
| 142 | Return<void> resetTxPowerScenario( |
| 143 | resetTxPowerScenario_cb hidl_status_cb) override; |
Ahmed ElArabawy | eaf8240 | 2018-10-26 09:46:04 -0700 | [diff] [blame] | 144 | Return<void> setLatencyMode(LatencyMode mode, |
| 145 | setLatencyMode_cb hidl_status_cb) override; |
Roshan Pius | 1ce92cf | 2018-01-22 16:12:19 -0800 | [diff] [blame] | 146 | Return<void> registerEventCallback_1_2( |
Jong Wook Kim | da830c9 | 2018-07-23 15:29:38 -0700 | [diff] [blame] | 147 | const sp<V1_2::IWifiChipEventCallback>& event_callback, |
Roshan Pius | 1ce92cf | 2018-01-22 16:12:19 -0800 | [diff] [blame] | 148 | registerEventCallback_1_2_cb hidl_status_cb) override; |
Ahmed ElArabawy | 6a1accf | 2018-01-23 10:57:29 -0800 | [diff] [blame] | 149 | Return<void> selectTxPowerScenario_1_2( |
| 150 | TxPowerScenario scenario, |
| 151 | selectTxPowerScenario_cb hidl_status_cb) override; |
Ahmed ElArabawy | eaf8240 | 2018-10-26 09:46:04 -0700 | [diff] [blame] | 152 | Return<void> getCapabilities_1_3( |
| 153 | getCapabilities_cb hidl_status_cb) override; |
Ahmed ElArabawy | 6a1accf | 2018-01-23 10:57:29 -0800 | [diff] [blame] | 154 | Return<void> debug(const hidl_handle& handle, |
| 155 | const hidl_vec<hidl_string>& options) override; |
Ahmed ElArabawy | eeb5338 | 2019-10-10 20:18:31 -0700 | [diff] [blame] | 156 | Return<void> createRttController_1_4( |
| 157 | const sp<IWifiIface>& bound_iface, |
| 158 | createRttController_1_4_cb hidl_status_cb) override; |
Ahmed ElArabawy | fd809fc | 2019-11-15 18:19:15 -0800 | [diff] [blame] | 159 | Return<void> registerEventCallback_1_4( |
| 160 | const sp<IWifiChipEventCallback>& event_callback, |
| 161 | registerEventCallback_1_4_cb hidl_status_cb) override; |
Jong Wook Kim | da830c9 | 2018-07-23 15:29:38 -0700 | [diff] [blame] | 162 | |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 163 | private: |
| 164 | void invalidateAndRemoveAllIfaces(); |
Roshan Pius | 8236850 | 2019-05-16 12:53:02 -0700 | [diff] [blame] | 165 | // When a STA iface is removed any dependent NAN-ifaces/RTT-controllers are |
| 166 | // invalidated & removed. |
| 167 | void invalidateAndRemoveDependencies(const std::string& removed_iface_name); |
Roshan Pius | 35d958c | 2016-10-06 16:47:38 -0700 | [diff] [blame] | 168 | |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 169 | // Corresponding worker functions for the HIDL methods. |
| 170 | std::pair<WifiStatus, ChipId> getIdInternal(); |
Jong Wook Kim | da830c9 | 2018-07-23 15:29:38 -0700 | [diff] [blame] | 171 | // Deprecated support for this callback |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 172 | WifiStatus registerEventCallbackInternal( |
Roshan Pius | 1ce92cf | 2018-01-22 16:12:19 -0800 | [diff] [blame] | 173 | const sp<V1_0::IWifiChipEventCallback>& event_callback); |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 174 | std::pair<WifiStatus, uint32_t> getCapabilitiesInternal(); |
| 175 | std::pair<WifiStatus, std::vector<ChipMode>> getAvailableModesInternal(); |
Roshan Pius | ba38d9c | 2017-12-08 07:32:08 -0800 | [diff] [blame] | 176 | WifiStatus configureChipInternal( |
| 177 | std::unique_lock<std::recursive_mutex>* lock, ChipModeId mode_id); |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 178 | std::pair<WifiStatus, uint32_t> getModeInternal(); |
| 179 | std::pair<WifiStatus, IWifiChip::ChipDebugInfo> |
| 180 | requestChipDebugInfoInternal(); |
| 181 | std::pair<WifiStatus, std::vector<uint8_t>> |
| 182 | requestDriverDebugDumpInternal(); |
| 183 | std::pair<WifiStatus, std::vector<uint8_t>> |
| 184 | requestFirmwareDebugDumpInternal(); |
| 185 | std::pair<WifiStatus, sp<IWifiApIface>> createApIfaceInternal(); |
| 186 | std::pair<WifiStatus, std::vector<hidl_string>> getApIfaceNamesInternal(); |
| 187 | std::pair<WifiStatus, sp<IWifiApIface>> getApIfaceInternal( |
| 188 | const std::string& ifname); |
| 189 | WifiStatus removeApIfaceInternal(const std::string& ifname); |
| 190 | std::pair<WifiStatus, sp<IWifiNanIface>> createNanIfaceInternal(); |
| 191 | std::pair<WifiStatus, std::vector<hidl_string>> getNanIfaceNamesInternal(); |
| 192 | std::pair<WifiStatus, sp<IWifiNanIface>> getNanIfaceInternal( |
| 193 | const std::string& ifname); |
| 194 | WifiStatus removeNanIfaceInternal(const std::string& ifname); |
| 195 | std::pair<WifiStatus, sp<IWifiP2pIface>> createP2pIfaceInternal(); |
| 196 | std::pair<WifiStatus, std::vector<hidl_string>> getP2pIfaceNamesInternal(); |
| 197 | std::pair<WifiStatus, sp<IWifiP2pIface>> getP2pIfaceInternal( |
| 198 | const std::string& ifname); |
| 199 | WifiStatus removeP2pIfaceInternal(const std::string& ifname); |
Ahmed ElArabawy | b23485d | 2019-12-09 15:24:16 -0800 | [diff] [blame^] | 200 | std::pair<WifiStatus, sp<V1_3::IWifiStaIface>> createStaIfaceInternal(); |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 201 | std::pair<WifiStatus, std::vector<hidl_string>> getStaIfaceNamesInternal(); |
Ahmed ElArabawy | b23485d | 2019-12-09 15:24:16 -0800 | [diff] [blame^] | 202 | std::pair<WifiStatus, sp<V1_3::IWifiStaIface>> getStaIfaceInternal( |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 203 | const std::string& ifname); |
| 204 | WifiStatus removeStaIfaceInternal(const std::string& ifname); |
Ahmed ElArabawy | eeb5338 | 2019-10-10 20:18:31 -0700 | [diff] [blame] | 205 | std::pair<WifiStatus, sp<V1_0::IWifiRttController>> |
| 206 | createRttControllerInternal(const sp<IWifiIface>& bound_iface); |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 207 | std::pair<WifiStatus, std::vector<WifiDebugRingBufferStatus>> |
| 208 | getDebugRingBuffersStatusInternal(); |
| 209 | WifiStatus startLoggingToDebugRingBufferInternal( |
| 210 | const hidl_string& ring_name, |
| 211 | WifiDebugRingBufferVerboseLevel verbose_level, |
| 212 | uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes); |
| 213 | WifiStatus forceDumpToDebugRingBufferInternal(const hidl_string& ring_name); |
Roger Wang | b294c76 | 2018-11-02 15:34:39 +0800 | [diff] [blame] | 214 | WifiStatus flushRingBufferToFileInternal(); |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 215 | WifiStatus stopLoggingToDebugRingBufferInternal(); |
| 216 | std::pair<WifiStatus, WifiDebugHostWakeReasonStats> |
| 217 | getDebugHostWakeReasonStatsInternal(); |
| 218 | WifiStatus enableDebugErrorAlertsInternal(bool enable); |
Jong Wook Kim | da830c9 | 2018-07-23 15:29:38 -0700 | [diff] [blame] | 219 | WifiStatus selectTxPowerScenarioInternal( |
| 220 | V1_1::IWifiChip::TxPowerScenario scenario); |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 221 | WifiStatus resetTxPowerScenarioInternal(); |
Ahmed ElArabawy | eaf8240 | 2018-10-26 09:46:04 -0700 | [diff] [blame] | 222 | WifiStatus setLatencyModeInternal(LatencyMode mode); |
Roshan Pius | 1ce92cf | 2018-01-22 16:12:19 -0800 | [diff] [blame] | 223 | WifiStatus registerEventCallbackInternal_1_2( |
Jong Wook Kim | da830c9 | 2018-07-23 15:29:38 -0700 | [diff] [blame] | 224 | const sp<V1_2::IWifiChipEventCallback>& event_callback); |
Ahmed ElArabawy | 6a1accf | 2018-01-23 10:57:29 -0800 | [diff] [blame] | 225 | WifiStatus selectTxPowerScenarioInternal_1_2(TxPowerScenario scenario); |
Ahmed ElArabawy | eaf8240 | 2018-10-26 09:46:04 -0700 | [diff] [blame] | 226 | std::pair<WifiStatus, uint32_t> getCapabilitiesInternal_1_3(); |
Ahmed ElArabawy | eeb5338 | 2019-10-10 20:18:31 -0700 | [diff] [blame] | 227 | std::pair<WifiStatus, sp<IWifiRttController>> |
| 228 | createRttControllerInternal_1_4(const sp<IWifiIface>& bound_iface); |
Ahmed ElArabawy | fd809fc | 2019-11-15 18:19:15 -0800 | [diff] [blame] | 229 | WifiStatus registerEventCallbackInternal_1_4( |
| 230 | const sp<IWifiChipEventCallback>& event_callback); |
| 231 | |
Roshan Pius | ba38d9c | 2017-12-08 07:32:08 -0800 | [diff] [blame] | 232 | WifiStatus handleChipConfiguration( |
| 233 | std::unique_lock<std::recursive_mutex>* lock, ChipModeId mode_id); |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 234 | WifiStatus registerDebugRingBufferCallback(); |
Roshan Pius | 85c6441 | 2018-01-22 17:58:40 -0800 | [diff] [blame] | 235 | WifiStatus registerRadioModeChangeCallback(); |
Roshan Pius | 2c06a3f | 2016-12-15 17:51:40 -0800 | [diff] [blame] | 236 | |
Roshan Pius | cc33820 | 2017-11-02 13:54:09 -0700 | [diff] [blame] | 237 | std::vector<IWifiChip::ChipIfaceCombination> |
| 238 | getCurrentModeIfaceCombinations(); |
| 239 | std::map<IfaceType, size_t> getCurrentIfaceCombination(); |
| 240 | std::vector<std::map<IfaceType, size_t>> expandIfaceCombinations( |
| 241 | const IWifiChip::ChipIfaceCombination& combination); |
Roshan Pius | a3e5b7f | 2019-03-25 13:52:45 -0700 | [diff] [blame] | 242 | bool canExpandedIfaceComboSupportIfaceOfTypeWithCurrentIfaces( |
| 243 | const std::map<IfaceType, size_t>& expanded_combo, |
| 244 | IfaceType requested_type); |
| 245 | bool canCurrentModeSupportIfaceOfTypeWithCurrentIfaces( |
| 246 | IfaceType requested_type); |
| 247 | bool canExpandedIfaceComboSupportIfaceCombo( |
| 248 | const std::map<IfaceType, size_t>& expanded_combo, |
| 249 | const std::map<IfaceType, size_t>& req_combo); |
| 250 | bool canCurrentModeSupportIfaceCombo( |
| 251 | const std::map<IfaceType, size_t>& req_combo); |
| 252 | bool canCurrentModeSupportIfaceOfType(IfaceType requested_type); |
Roshan Pius | cc33820 | 2017-11-02 13:54:09 -0700 | [diff] [blame] | 253 | bool isValidModeId(ChipModeId mode_id); |
Roshan Pius | a3e5b7f | 2019-03-25 13:52:45 -0700 | [diff] [blame] | 254 | bool isStaApConcurrencyAllowedInCurrentMode(); |
James Mattis | d2e4c07 | 2019-05-22 16:14:48 -0700 | [diff] [blame] | 255 | bool isDualApAllowedInCurrentMode(); |
Roshan Pius | 6036c02 | 2019-03-27 10:41:58 -0700 | [diff] [blame] | 256 | std::string getFirstActiveWlanIfaceName(); |
Roshan Pius | a3e5b7f | 2019-03-25 13:52:45 -0700 | [diff] [blame] | 257 | std::string allocateApOrStaIfaceName(uint32_t start_idx); |
| 258 | std::string allocateApIfaceName(); |
| 259 | std::string allocateStaIfaceName(); |
xshu | 5899e8e | 2018-01-09 15:36:03 -0800 | [diff] [blame] | 260 | bool writeRingbufferFilesInternal(); |
Roshan Pius | cc33820 | 2017-11-02 13:54:09 -0700 | [diff] [blame] | 261 | |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 262 | ChipId chip_id_; |
| 263 | std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_; |
| 264 | std::weak_ptr<mode_controller::WifiModeController> mode_controller_; |
Roshan Pius | 99dab38 | 2019-02-14 07:57:10 -0800 | [diff] [blame] | 265 | std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_; |
Roshan Pius | 675609b | 2017-10-31 14:24:58 -0700 | [diff] [blame] | 266 | std::vector<sp<WifiApIface>> ap_ifaces_; |
| 267 | std::vector<sp<WifiNanIface>> nan_ifaces_; |
| 268 | std::vector<sp<WifiP2pIface>> p2p_ifaces_; |
| 269 | std::vector<sp<WifiStaIface>> sta_ifaces_; |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 270 | std::vector<sp<WifiRttController>> rtt_controllers_; |
xshu | 5899e8e | 2018-01-09 15:36:03 -0800 | [diff] [blame] | 271 | std::map<std::string, Ringbuffer> ringbuffer_map_; |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 272 | bool is_valid_; |
Roshan Pius | cc33820 | 2017-11-02 13:54:09 -0700 | [diff] [blame] | 273 | // Members pertaining to chip configuration. |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 274 | uint32_t current_mode_id_; |
Roshan Pius | cc33820 | 2017-11-02 13:54:09 -0700 | [diff] [blame] | 275 | std::vector<IWifiChip::ChipMode> modes_; |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 276 | // The legacy ring buffer callback API has only a global callback |
| 277 | // registration mechanism. Use this to check if we have already |
| 278 | // registered a callback. |
| 279 | bool debug_ring_buffer_cb_registered_; |
Ahmed ElArabawy | fd809fc | 2019-11-15 18:19:15 -0800 | [diff] [blame] | 280 | hidl_callback_util::HidlCallbackHandler<IWifiChipEventCallback> |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 281 | event_cb_handler_; |
Roshan Pius | 3c4e8a3 | 2016-10-03 14:53:58 -0700 | [diff] [blame] | 282 | |
Roshan Pius | abcf78f | 2017-10-06 16:30:38 -0700 | [diff] [blame] | 283 | DISALLOW_COPY_AND_ASSIGN(WifiChip); |
Roshan Pius | 3c4e8a3 | 2016-10-03 14:53:58 -0700 | [diff] [blame] | 284 | }; |
| 285 | |
Roshan Pius | 79a9975 | 2016-10-04 13:03:58 -0700 | [diff] [blame] | 286 | } // namespace implementation |
Ahmed ElArabawy | f501a98 | 2019-07-23 15:02:22 -0700 | [diff] [blame] | 287 | } // namespace V1_4 |
Roshan Pius | 3c4e8a3 | 2016-10-03 14:53:58 -0700 | [diff] [blame] | 288 | } // namespace wifi |
| 289 | } // namespace hardware |
| 290 | } // namespace android |
| 291 | |
| 292 | #endif // WIFI_CHIP_H_ |