blob: 693d480bda4e8d4c8a641dd1efebb144e3fdcb3d [file] [log] [blame]
Roshan Pius3c4e8a32016-10-03 14:53:58 -07001/*
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
xshu5899e8e2018-01-09 15:36:03 -080020#include <list>
Roshan Pius35d958c2016-10-06 16:47:38 -070021#include <map>
Veerendranath Jakkam25b3a6f2020-04-14 22:04:39 +053022#include <mutex>
Roshan Pius3c4e8a32016-10-03 14:53:58 -070023
Roshan Pius3c4e8a32016-10-03 14:53:58 -070024#include <android-base/macros.h>
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -070025#include <android/hardware/wifi/1.4/IWifiRttController.h>
Jimmy Chen1bdf1a72019-12-23 17:53:40 +020026#include <android/hardware/wifi/1.5/IWifiChip.h>
Roshan Pius3c4e8a32016-10-03 14:53:58 -070027
Roshan Piusd37341f2017-01-31 13:13:28 -080028#include "hidl_callback_util.h"
xshu5899e8e2018-01-09 15:36:03 -080029#include "ringbuffer.h"
Roshan Pius35d958c2016-10-06 16:47:38 -070030#include "wifi_ap_iface.h"
Roshan Pius200a17d2017-11-01 13:03:35 -070031#include "wifi_feature_flags.h"
Roshan Piusaabe5752016-09-29 09:03:59 -070032#include "wifi_legacy_hal.h"
Roshan Pius52947fb2016-11-18 11:38:07 -080033#include "wifi_mode_controller.h"
Roshan Pius35d958c2016-10-06 16:47:38 -070034#include "wifi_nan_iface.h"
35#include "wifi_p2p_iface.h"
Roshan Pius59268282016-10-06 20:23:47 -070036#include "wifi_rtt_controller.h"
Roshan Pius35d958c2016-10-06 16:47:38 -070037#include "wifi_sta_iface.h"
Roshan Pius3c4e8a32016-10-03 14:53:58 -070038
39namespace android {
40namespace hardware {
41namespace wifi {
Jimmy Chend460df32019-11-29 17:31:22 +020042namespace V1_5 {
Roshan Pius79a99752016-10-04 13:03:58 -070043namespace implementation {
Roshan Piusdbd83ef2017-06-20 12:05:40 -070044using namespace android::hardware::wifi::V1_0;
Roshan Pius3c4e8a32016-10-03 14:53:58 -070045
Roshan Piusaabe5752016-09-29 09:03:59 -070046/**
47 * HIDL interface object used to control a Wifi HAL chip instance.
48 * Since there is only a single chip instance used today, there is no
49 * identifying handle information stored here.
50 */
Jimmy Chen1bdf1a72019-12-23 17:53:40 +020051class WifiChip : public V1_5::IWifiChip {
Roshan Piusabcf78f2017-10-06 16:30:38 -070052 public:
Jimmy Chen2dddd792019-12-23 17:50:39 +020053 WifiChip(ChipId chip_id, bool is_primary,
Ahmed ElArabawy2134bf72020-06-18 15:07:12 -070054 const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
55 const std::weak_ptr<mode_controller::WifiModeController>
56 mode_controller,
57 const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util,
58 const std::weak_ptr<feature_flags::WifiFeatureFlags> feature_flags,
59 const std::function<void(const std::string&)>&
60 subsystemCallbackHandler);
Roshan Piusabcf78f2017-10-06 16:30:38 -070061 // HIDL does not provide a built-in mechanism to let the server invalidate
62 // a HIDL interface object after creation. If any client process holds onto
63 // a reference to the object in their context, any method calls on that
64 // reference will continue to be directed to the server.
65 //
66 // However Wifi HAL needs to control the lifetime of these objects. So, add
67 // a public |invalidate| method to |WifiChip| and it's child objects. This
68 // will be used to mark an object invalid when either:
69 // a) Wifi HAL is stopped, or
70 // b) Wifi Chip is reconfigured.
71 //
72 // All HIDL method implementations should check if the object is still
73 // marked valid before processing them.
74 void invalidate();
75 bool isValid();
Jimmy Chend460df32019-11-29 17:31:22 +020076 std::set<sp<V1_4::IWifiChipEventCallback>> getEventCallbacks();
Roshan Pius3c4e8a32016-10-03 14:53:58 -070077
Roshan Piusabcf78f2017-10-06 16:30:38 -070078 // HIDL methods exposed.
79 Return<void> getId(getId_cb hidl_status_cb) override;
Jong Wook Kimda830c92018-07-23 15:29:38 -070080 // Deprecated support for this callback
Roshan Piusabcf78f2017-10-06 16:30:38 -070081 Return<void> registerEventCallback(
Roshan Pius1ce92cf2018-01-22 16:12:19 -080082 const sp<V1_0::IWifiChipEventCallback>& event_callback,
Roshan Piusabcf78f2017-10-06 16:30:38 -070083 registerEventCallback_cb hidl_status_cb) override;
84 Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override;
85 Return<void> getAvailableModes(
86 getAvailableModes_cb hidl_status_cb) override;
87 Return<void> configureChip(ChipModeId mode_id,
88 configureChip_cb hidl_status_cb) override;
89 Return<void> getMode(getMode_cb hidl_status_cb) override;
90 Return<void> requestChipDebugInfo(
91 requestChipDebugInfo_cb hidl_status_cb) override;
92 Return<void> requestDriverDebugDump(
93 requestDriverDebugDump_cb hidl_status_cb) override;
94 Return<void> requestFirmwareDebugDump(
95 requestFirmwareDebugDump_cb hidl_status_cb) override;
96 Return<void> createApIface(createApIface_cb hidl_status_cb) override;
97 Return<void> getApIfaceNames(getApIfaceNames_cb hidl_status_cb) override;
98 Return<void> getApIface(const hidl_string& ifname,
99 getApIface_cb hidl_status_cb) override;
100 Return<void> removeApIface(const hidl_string& ifname,
101 removeApIface_cb hidl_status_cb) override;
102 Return<void> createNanIface(createNanIface_cb hidl_status_cb) override;
103 Return<void> getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) override;
104 Return<void> getNanIface(const hidl_string& ifname,
105 getNanIface_cb hidl_status_cb) override;
106 Return<void> removeNanIface(const hidl_string& ifname,
107 removeNanIface_cb hidl_status_cb) override;
108 Return<void> createP2pIface(createP2pIface_cb hidl_status_cb) override;
109 Return<void> getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) override;
110 Return<void> getP2pIface(const hidl_string& ifname,
111 getP2pIface_cb hidl_status_cb) override;
112 Return<void> removeP2pIface(const hidl_string& ifname,
113 removeP2pIface_cb hidl_status_cb) override;
114 Return<void> createStaIface(createStaIface_cb hidl_status_cb) override;
115 Return<void> getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) override;
116 Return<void> getStaIface(const hidl_string& ifname,
117 getStaIface_cb hidl_status_cb) override;
118 Return<void> removeStaIface(const hidl_string& ifname,
119 removeStaIface_cb hidl_status_cb) override;
120 Return<void> createRttController(
121 const sp<IWifiIface>& bound_iface,
122 createRttController_cb hidl_status_cb) override;
123 Return<void> getDebugRingBuffersStatus(
124 getDebugRingBuffersStatus_cb hidl_status_cb) override;
125 Return<void> startLoggingToDebugRingBuffer(
126 const hidl_string& ring_name,
127 WifiDebugRingBufferVerboseLevel verbose_level,
128 uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes,
129 startLoggingToDebugRingBuffer_cb hidl_status_cb) override;
130 Return<void> forceDumpToDebugRingBuffer(
131 const hidl_string& ring_name,
132 forceDumpToDebugRingBuffer_cb hidl_status_cb) override;
Roger Wangb294c762018-11-02 15:34:39 +0800133 Return<void> flushRingBufferToFile(
134 flushRingBufferToFile_cb hidl_status_cb) override;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700135 Return<void> stopLoggingToDebugRingBuffer(
136 stopLoggingToDebugRingBuffer_cb hidl_status_cb) override;
137 Return<void> getDebugHostWakeReasonStats(
138 getDebugHostWakeReasonStats_cb hidl_status_cb) override;
139 Return<void> enableDebugErrorAlerts(
140 bool enable, enableDebugErrorAlerts_cb hidl_status_cb) override;
141 Return<void> selectTxPowerScenario(
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800142 V1_1::IWifiChip::TxPowerScenario scenario,
Roshan Piusabcf78f2017-10-06 16:30:38 -0700143 selectTxPowerScenario_cb hidl_status_cb) override;
144 Return<void> resetTxPowerScenario(
145 resetTxPowerScenario_cb hidl_status_cb) override;
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700146 Return<void> setLatencyMode(LatencyMode mode,
147 setLatencyMode_cb hidl_status_cb) override;
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800148 Return<void> registerEventCallback_1_2(
Jong Wook Kimda830c92018-07-23 15:29:38 -0700149 const sp<V1_2::IWifiChipEventCallback>& event_callback,
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800150 registerEventCallback_1_2_cb hidl_status_cb) override;
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800151 Return<void> selectTxPowerScenario_1_2(
152 TxPowerScenario scenario,
153 selectTxPowerScenario_cb hidl_status_cb) override;
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700154 Return<void> getCapabilities_1_3(
155 getCapabilities_cb hidl_status_cb) override;
Jimmy Chen1bdf1a72019-12-23 17:53:40 +0200156 Return<void> getCapabilities_1_5(
157 getCapabilities_1_5_cb hidl_status_cb) override;
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800158 Return<void> debug(const hidl_handle& handle,
159 const hidl_vec<hidl_string>& options) override;
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -0700160 Return<void> createRttController_1_4(
161 const sp<IWifiIface>& bound_iface,
162 createRttController_1_4_cb hidl_status_cb) override;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800163 Return<void> registerEventCallback_1_4(
Jimmy Chend460df32019-11-29 17:31:22 +0200164 const sp<V1_4::IWifiChipEventCallback>& event_callback,
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800165 registerEventCallback_1_4_cb hidl_status_cb) override;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800166 Return<void> setMultiStaPrimaryConnection(
167 const hidl_string& ifname,
168 setMultiStaPrimaryConnection_cb hidl_status_cb) override;
169 Return<void> setMultiStaUseCase(
170 MultiStaUseCase use_case,
171 setMultiStaUseCase_cb hidl_status_cb) override;
Jong Wook Kimda830c92018-07-23 15:29:38 -0700172
Roshan Piusabcf78f2017-10-06 16:30:38 -0700173 private:
174 void invalidateAndRemoveAllIfaces();
Roshan Pius82368502019-05-16 12:53:02 -0700175 // When a STA iface is removed any dependent NAN-ifaces/RTT-controllers are
176 // invalidated & removed.
177 void invalidateAndRemoveDependencies(const std::string& removed_iface_name);
Roshan Pius35d958c2016-10-06 16:47:38 -0700178
Roshan Piusabcf78f2017-10-06 16:30:38 -0700179 // Corresponding worker functions for the HIDL methods.
180 std::pair<WifiStatus, ChipId> getIdInternal();
Jong Wook Kimda830c92018-07-23 15:29:38 -0700181 // Deprecated support for this callback
Roshan Piusabcf78f2017-10-06 16:30:38 -0700182 WifiStatus registerEventCallbackInternal(
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800183 const sp<V1_0::IWifiChipEventCallback>& event_callback);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700184 std::pair<WifiStatus, uint32_t> getCapabilitiesInternal();
185 std::pair<WifiStatus, std::vector<ChipMode>> getAvailableModesInternal();
Roshan Piusba38d9c2017-12-08 07:32:08 -0800186 WifiStatus configureChipInternal(
187 std::unique_lock<std::recursive_mutex>* lock, ChipModeId mode_id);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700188 std::pair<WifiStatus, uint32_t> getModeInternal();
189 std::pair<WifiStatus, IWifiChip::ChipDebugInfo>
190 requestChipDebugInfoInternal();
191 std::pair<WifiStatus, std::vector<uint8_t>>
192 requestDriverDebugDumpInternal();
193 std::pair<WifiStatus, std::vector<uint8_t>>
194 requestFirmwareDebugDumpInternal();
195 std::pair<WifiStatus, sp<IWifiApIface>> createApIfaceInternal();
196 std::pair<WifiStatus, std::vector<hidl_string>> getApIfaceNamesInternal();
197 std::pair<WifiStatus, sp<IWifiApIface>> getApIfaceInternal(
198 const std::string& ifname);
199 WifiStatus removeApIfaceInternal(const std::string& ifname);
Jimmy Chend460df32019-11-29 17:31:22 +0200200 std::pair<WifiStatus, sp<V1_4::IWifiNanIface>> createNanIfaceInternal();
Roshan Piusabcf78f2017-10-06 16:30:38 -0700201 std::pair<WifiStatus, std::vector<hidl_string>> getNanIfaceNamesInternal();
Jimmy Chend460df32019-11-29 17:31:22 +0200202 std::pair<WifiStatus, sp<V1_4::IWifiNanIface>> getNanIfaceInternal(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700203 const std::string& ifname);
204 WifiStatus removeNanIfaceInternal(const std::string& ifname);
205 std::pair<WifiStatus, sp<IWifiP2pIface>> createP2pIfaceInternal();
206 std::pair<WifiStatus, std::vector<hidl_string>> getP2pIfaceNamesInternal();
207 std::pair<WifiStatus, sp<IWifiP2pIface>> getP2pIfaceInternal(
208 const std::string& ifname);
209 WifiStatus removeP2pIfaceInternal(const std::string& ifname);
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800210 std::pair<WifiStatus, sp<V1_5::IWifiStaIface>> createStaIfaceInternal();
Roshan Piusabcf78f2017-10-06 16:30:38 -0700211 std::pair<WifiStatus, std::vector<hidl_string>> getStaIfaceNamesInternal();
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800212 std::pair<WifiStatus, sp<V1_5::IWifiStaIface>> getStaIfaceInternal(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700213 const std::string& ifname);
214 WifiStatus removeStaIfaceInternal(const std::string& ifname);
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -0700215 std::pair<WifiStatus, sp<V1_0::IWifiRttController>>
216 createRttControllerInternal(const sp<IWifiIface>& bound_iface);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700217 std::pair<WifiStatus, std::vector<WifiDebugRingBufferStatus>>
218 getDebugRingBuffersStatusInternal();
219 WifiStatus startLoggingToDebugRingBufferInternal(
220 const hidl_string& ring_name,
221 WifiDebugRingBufferVerboseLevel verbose_level,
222 uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes);
223 WifiStatus forceDumpToDebugRingBufferInternal(const hidl_string& ring_name);
Roger Wangb294c762018-11-02 15:34:39 +0800224 WifiStatus flushRingBufferToFileInternal();
Roshan Piusabcf78f2017-10-06 16:30:38 -0700225 WifiStatus stopLoggingToDebugRingBufferInternal();
226 std::pair<WifiStatus, WifiDebugHostWakeReasonStats>
227 getDebugHostWakeReasonStatsInternal();
228 WifiStatus enableDebugErrorAlertsInternal(bool enable);
Jong Wook Kimda830c92018-07-23 15:29:38 -0700229 WifiStatus selectTxPowerScenarioInternal(
230 V1_1::IWifiChip::TxPowerScenario scenario);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700231 WifiStatus resetTxPowerScenarioInternal();
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700232 WifiStatus setLatencyModeInternal(LatencyMode mode);
Roshan Pius1ce92cf2018-01-22 16:12:19 -0800233 WifiStatus registerEventCallbackInternal_1_2(
Jong Wook Kimda830c92018-07-23 15:29:38 -0700234 const sp<V1_2::IWifiChipEventCallback>& event_callback);
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800235 WifiStatus selectTxPowerScenarioInternal_1_2(TxPowerScenario scenario);
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700236 std::pair<WifiStatus, uint32_t> getCapabilitiesInternal_1_3();
Jimmy Chen1bdf1a72019-12-23 17:53:40 +0200237 std::pair<WifiStatus, uint32_t> getCapabilitiesInternal_1_5();
Jimmy Chend460df32019-11-29 17:31:22 +0200238 std::pair<WifiStatus, sp<V1_4::IWifiRttController>>
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -0700239 createRttControllerInternal_1_4(const sp<IWifiIface>& bound_iface);
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800240 WifiStatus registerEventCallbackInternal_1_4(
Jimmy Chend460df32019-11-29 17:31:22 +0200241 const sp<V1_4::IWifiChipEventCallback>& event_callback);
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800242 WifiStatus setMultiStaPrimaryConnectionInternal(const std::string& ifname);
243 WifiStatus setMultiStaUseCaseInternal(MultiStaUseCase use_case);
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800244
Roshan Piusba38d9c2017-12-08 07:32:08 -0800245 WifiStatus handleChipConfiguration(
246 std::unique_lock<std::recursive_mutex>* lock, ChipModeId mode_id);
Roshan Piusabcf78f2017-10-06 16:30:38 -0700247 WifiStatus registerDebugRingBufferCallback();
Roshan Pius85c64412018-01-22 17:58:40 -0800248 WifiStatus registerRadioModeChangeCallback();
Roshan Pius2c06a3f2016-12-15 17:51:40 -0800249
Jimmy Chend460df32019-11-29 17:31:22 +0200250 std::vector<V1_4::IWifiChip::ChipIfaceCombination>
Roshan Piuscc338202017-11-02 13:54:09 -0700251 getCurrentModeIfaceCombinations();
252 std::map<IfaceType, size_t> getCurrentIfaceCombination();
253 std::vector<std::map<IfaceType, size_t>> expandIfaceCombinations(
Jimmy Chend460df32019-11-29 17:31:22 +0200254 const V1_4::IWifiChip::ChipIfaceCombination& combination);
Roshan Piusa3e5b7f2019-03-25 13:52:45 -0700255 bool canExpandedIfaceComboSupportIfaceOfTypeWithCurrentIfaces(
256 const std::map<IfaceType, size_t>& expanded_combo,
257 IfaceType requested_type);
258 bool canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(
259 IfaceType requested_type);
260 bool canExpandedIfaceComboSupportIfaceCombo(
261 const std::map<IfaceType, size_t>& expanded_combo,
262 const std::map<IfaceType, size_t>& req_combo);
263 bool canCurrentModeSupportIfaceCombo(
264 const std::map<IfaceType, size_t>& req_combo);
265 bool canCurrentModeSupportIfaceOfType(IfaceType requested_type);
Roshan Piuscc338202017-11-02 13:54:09 -0700266 bool isValidModeId(ChipModeId mode_id);
Roshan Piusa3e5b7f2019-03-25 13:52:45 -0700267 bool isStaApConcurrencyAllowedInCurrentMode();
James Mattisd2e4c072019-05-22 16:14:48 -0700268 bool isDualApAllowedInCurrentMode();
Roshan Pius6036c022019-03-27 10:41:58 -0700269 std::string getFirstActiveWlanIfaceName();
Jimmy Chen2dddd792019-12-23 17:50:39 +0200270 std::string allocateApOrStaIfaceName(IfaceType type, uint32_t start_idx);
Roshan Piusa3e5b7f2019-03-25 13:52:45 -0700271 std::string allocateApIfaceName();
272 std::string allocateStaIfaceName();
xshu5899e8e2018-01-09 15:36:03 -0800273 bool writeRingbufferFilesInternal();
Jimmy Chen2dddd792019-12-23 17:50:39 +0200274 std::string getWlanIfaceNameWithType(IfaceType type, unsigned idx);
Roshan Piuscc338202017-11-02 13:54:09 -0700275
Roshan Piusabcf78f2017-10-06 16:30:38 -0700276 ChipId chip_id_;
277 std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
278 std::weak_ptr<mode_controller::WifiModeController> mode_controller_;
Roshan Pius99dab382019-02-14 07:57:10 -0800279 std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
Roshan Pius675609b2017-10-31 14:24:58 -0700280 std::vector<sp<WifiApIface>> ap_ifaces_;
281 std::vector<sp<WifiNanIface>> nan_ifaces_;
282 std::vector<sp<WifiP2pIface>> p2p_ifaces_;
283 std::vector<sp<WifiStaIface>> sta_ifaces_;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700284 std::vector<sp<WifiRttController>> rtt_controllers_;
xshu5899e8e2018-01-09 15:36:03 -0800285 std::map<std::string, Ringbuffer> ringbuffer_map_;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700286 bool is_valid_;
Roshan Piuscc338202017-11-02 13:54:09 -0700287 // Members pertaining to chip configuration.
Roshan Piusabcf78f2017-10-06 16:30:38 -0700288 uint32_t current_mode_id_;
Veerendranath Jakkam25b3a6f2020-04-14 22:04:39 +0530289 std::mutex lock_t;
Jimmy Chend460df32019-11-29 17:31:22 +0200290 std::vector<V1_4::IWifiChip::ChipMode> modes_;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700291 // The legacy ring buffer callback API has only a global callback
292 // registration mechanism. Use this to check if we have already
293 // registered a callback.
294 bool debug_ring_buffer_cb_registered_;
Jimmy Chend460df32019-11-29 17:31:22 +0200295 hidl_callback_util::HidlCallbackHandler<V1_4::IWifiChipEventCallback>
Roshan Piusabcf78f2017-10-06 16:30:38 -0700296 event_cb_handler_;
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700297
Ahmed ElArabawy2134bf72020-06-18 15:07:12 -0700298 const std::function<void(const std::string&)> subsystemCallbackHandler_;
299
Roshan Piusabcf78f2017-10-06 16:30:38 -0700300 DISALLOW_COPY_AND_ASSIGN(WifiChip);
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700301};
302
Roshan Pius79a99752016-10-04 13:03:58 -0700303} // namespace implementation
Jimmy Chend460df32019-11-29 17:31:22 +0200304} // namespace V1_5
Roshan Pius3c4e8a32016-10-03 14:53:58 -0700305} // namespace wifi
306} // namespace hardware
307} // namespace android
308
309#endif // WIFI_CHIP_H_