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 #include <android-base/logging.h>
18 
19 #include "hidl_return_util.h"
20 #include "hidl_struct_util.h"
21 #include "wifi_chip.h"
22 #include "wifi_feature_flags.h"
23 #include "wifi_status_util.h"
24 
25 namespace {
26 using android::sp;
27 using android::hardware::hidl_vec;
28 using android::hardware::hidl_string;
29 using android::hardware::wifi::V1_0::ChipModeId;
30 using android::hardware::wifi::V1_0::IWifiChip;
31 using android::hardware::wifi::V1_0::IfaceType;
32 
33 constexpr ChipModeId kStaChipModeId = 0;
34 constexpr ChipModeId kApChipModeId = 1;
35 constexpr ChipModeId kInvalidModeId = UINT32_MAX;
36 
37 template <typename Iface>
invalidateAndClear(sp<Iface> & iface)38 void invalidateAndClear(sp<Iface>& iface) {
39   if (iface.get()) {
40     iface->invalidate();
41     iface.clear();
42   }
43 }
44 }  // namepsace
45 
46 namespace android {
47 namespace hardware {
48 namespace wifi {
49 namespace V1_0 {
50 namespace implementation {
51 using hidl_return_util::validateAndCall;
52 
WifiChip(ChipId chip_id,const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,const std::weak_ptr<mode_controller::WifiModeController> mode_controller)53 WifiChip::WifiChip(
54     ChipId chip_id,
55     const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
56     const std::weak_ptr<mode_controller::WifiModeController> mode_controller)
57     : chip_id_(chip_id),
58       legacy_hal_(legacy_hal),
59       mode_controller_(mode_controller),
60       is_valid_(true),
61       current_mode_id_(kInvalidModeId),
62       debug_ring_buffer_cb_registered_(false) {}
63 
invalidate()64 void WifiChip::invalidate() {
65   invalidateAndRemoveAllIfaces();
66   legacy_hal_.reset();
67   event_cb_handler_.invalidate();
68   is_valid_ = false;
69 }
70 
isValid()71 bool WifiChip::isValid() {
72   return is_valid_;
73 }
74 
getEventCallbacks()75 std::set<sp<IWifiChipEventCallback>> WifiChip::getEventCallbacks() {
76   return event_cb_handler_.getCallbacks();
77 }
78 
getId(getId_cb hidl_status_cb)79 Return<void> WifiChip::getId(getId_cb hidl_status_cb) {
80   return validateAndCall(this,
81                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
82                          &WifiChip::getIdInternal,
83                          hidl_status_cb);
84 }
85 
registerEventCallback(const sp<IWifiChipEventCallback> & event_callback,registerEventCallback_cb hidl_status_cb)86 Return<void> WifiChip::registerEventCallback(
87     const sp<IWifiChipEventCallback>& event_callback,
88     registerEventCallback_cb hidl_status_cb) {
89   return validateAndCall(this,
90                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
91                          &WifiChip::registerEventCallbackInternal,
92                          hidl_status_cb,
93                          event_callback);
94 }
95 
getCapabilities(getCapabilities_cb hidl_status_cb)96 Return<void> WifiChip::getCapabilities(getCapabilities_cb hidl_status_cb) {
97   return validateAndCall(this,
98                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
99                          &WifiChip::getCapabilitiesInternal,
100                          hidl_status_cb);
101 }
102 
getAvailableModes(getAvailableModes_cb hidl_status_cb)103 Return<void> WifiChip::getAvailableModes(getAvailableModes_cb hidl_status_cb) {
104   return validateAndCall(this,
105                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
106                          &WifiChip::getAvailableModesInternal,
107                          hidl_status_cb);
108 }
109 
configureChip(ChipModeId mode_id,configureChip_cb hidl_status_cb)110 Return<void> WifiChip::configureChip(ChipModeId mode_id,
111                                      configureChip_cb hidl_status_cb) {
112   return validateAndCall(this,
113                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
114                          &WifiChip::configureChipInternal,
115                          hidl_status_cb,
116                          mode_id);
117 }
118 
getMode(getMode_cb hidl_status_cb)119 Return<void> WifiChip::getMode(getMode_cb hidl_status_cb) {
120   return validateAndCall(this,
121                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
122                          &WifiChip::getModeInternal,
123                          hidl_status_cb);
124 }
125 
requestChipDebugInfo(requestChipDebugInfo_cb hidl_status_cb)126 Return<void> WifiChip::requestChipDebugInfo(
127     requestChipDebugInfo_cb hidl_status_cb) {
128   return validateAndCall(this,
129                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
130                          &WifiChip::requestChipDebugInfoInternal,
131                          hidl_status_cb);
132 }
133 
requestDriverDebugDump(requestDriverDebugDump_cb hidl_status_cb)134 Return<void> WifiChip::requestDriverDebugDump(
135     requestDriverDebugDump_cb hidl_status_cb) {
136   return validateAndCall(this,
137                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
138                          &WifiChip::requestDriverDebugDumpInternal,
139                          hidl_status_cb);
140 }
141 
requestFirmwareDebugDump(requestFirmwareDebugDump_cb hidl_status_cb)142 Return<void> WifiChip::requestFirmwareDebugDump(
143     requestFirmwareDebugDump_cb hidl_status_cb) {
144   return validateAndCall(this,
145                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
146                          &WifiChip::requestFirmwareDebugDumpInternal,
147                          hidl_status_cb);
148 }
149 
createApIface(createApIface_cb hidl_status_cb)150 Return<void> WifiChip::createApIface(createApIface_cb hidl_status_cb) {
151   return validateAndCall(this,
152                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
153                          &WifiChip::createApIfaceInternal,
154                          hidl_status_cb);
155 }
156 
getApIfaceNames(getApIfaceNames_cb hidl_status_cb)157 Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb hidl_status_cb) {
158   return validateAndCall(this,
159                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
160                          &WifiChip::getApIfaceNamesInternal,
161                          hidl_status_cb);
162 }
163 
getApIface(const hidl_string & ifname,getApIface_cb hidl_status_cb)164 Return<void> WifiChip::getApIface(const hidl_string& ifname,
165                                   getApIface_cb hidl_status_cb) {
166   return validateAndCall(this,
167                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
168                          &WifiChip::getApIfaceInternal,
169                          hidl_status_cb,
170                          ifname);
171 }
172 
removeApIface(const hidl_string & ifname,removeApIface_cb hidl_status_cb)173 Return<void> WifiChip::removeApIface(const hidl_string& ifname,
174                                      removeApIface_cb hidl_status_cb) {
175   return validateAndCall(this,
176                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
177                          &WifiChip::removeApIfaceInternal,
178                          hidl_status_cb,
179                          ifname);
180 }
181 
createNanIface(createNanIface_cb hidl_status_cb)182 Return<void> WifiChip::createNanIface(createNanIface_cb hidl_status_cb) {
183   return validateAndCall(this,
184                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
185                          &WifiChip::createNanIfaceInternal,
186                          hidl_status_cb);
187 }
188 
getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb)189 Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) {
190   return validateAndCall(this,
191                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
192                          &WifiChip::getNanIfaceNamesInternal,
193                          hidl_status_cb);
194 }
195 
getNanIface(const hidl_string & ifname,getNanIface_cb hidl_status_cb)196 Return<void> WifiChip::getNanIface(const hidl_string& ifname,
197                                    getNanIface_cb hidl_status_cb) {
198   return validateAndCall(this,
199                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
200                          &WifiChip::getNanIfaceInternal,
201                          hidl_status_cb,
202                          ifname);
203 }
204 
removeNanIface(const hidl_string & ifname,removeNanIface_cb hidl_status_cb)205 Return<void> WifiChip::removeNanIface(const hidl_string& ifname,
206                                       removeNanIface_cb hidl_status_cb) {
207   return validateAndCall(this,
208                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
209                          &WifiChip::removeNanIfaceInternal,
210                          hidl_status_cb,
211                          ifname);
212 }
213 
createP2pIface(createP2pIface_cb hidl_status_cb)214 Return<void> WifiChip::createP2pIface(createP2pIface_cb hidl_status_cb) {
215   return validateAndCall(this,
216                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
217                          &WifiChip::createP2pIfaceInternal,
218                          hidl_status_cb);
219 }
220 
getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb)221 Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) {
222   return validateAndCall(this,
223                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
224                          &WifiChip::getP2pIfaceNamesInternal,
225                          hidl_status_cb);
226 }
227 
getP2pIface(const hidl_string & ifname,getP2pIface_cb hidl_status_cb)228 Return<void> WifiChip::getP2pIface(const hidl_string& ifname,
229                                    getP2pIface_cb hidl_status_cb) {
230   return validateAndCall(this,
231                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
232                          &WifiChip::getP2pIfaceInternal,
233                          hidl_status_cb,
234                          ifname);
235 }
236 
removeP2pIface(const hidl_string & ifname,removeP2pIface_cb hidl_status_cb)237 Return<void> WifiChip::removeP2pIface(const hidl_string& ifname,
238                                       removeP2pIface_cb hidl_status_cb) {
239   return validateAndCall(this,
240                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
241                          &WifiChip::removeP2pIfaceInternal,
242                          hidl_status_cb,
243                          ifname);
244 }
245 
createStaIface(createStaIface_cb hidl_status_cb)246 Return<void> WifiChip::createStaIface(createStaIface_cb hidl_status_cb) {
247   return validateAndCall(this,
248                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
249                          &WifiChip::createStaIfaceInternal,
250                          hidl_status_cb);
251 }
252 
getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb)253 Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) {
254   return validateAndCall(this,
255                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
256                          &WifiChip::getStaIfaceNamesInternal,
257                          hidl_status_cb);
258 }
259 
getStaIface(const hidl_string & ifname,getStaIface_cb hidl_status_cb)260 Return<void> WifiChip::getStaIface(const hidl_string& ifname,
261                                    getStaIface_cb hidl_status_cb) {
262   return validateAndCall(this,
263                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
264                          &WifiChip::getStaIfaceInternal,
265                          hidl_status_cb,
266                          ifname);
267 }
268 
removeStaIface(const hidl_string & ifname,removeStaIface_cb hidl_status_cb)269 Return<void> WifiChip::removeStaIface(const hidl_string& ifname,
270                                       removeStaIface_cb hidl_status_cb) {
271   return validateAndCall(this,
272                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
273                          &WifiChip::removeStaIfaceInternal,
274                          hidl_status_cb,
275                          ifname);
276 }
277 
createRttController(const sp<IWifiIface> & bound_iface,createRttController_cb hidl_status_cb)278 Return<void> WifiChip::createRttController(
279     const sp<IWifiIface>& bound_iface, createRttController_cb hidl_status_cb) {
280   return validateAndCall(this,
281                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
282                          &WifiChip::createRttControllerInternal,
283                          hidl_status_cb,
284                          bound_iface);
285 }
286 
getDebugRingBuffersStatus(getDebugRingBuffersStatus_cb hidl_status_cb)287 Return<void> WifiChip::getDebugRingBuffersStatus(
288     getDebugRingBuffersStatus_cb hidl_status_cb) {
289   return validateAndCall(this,
290                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
291                          &WifiChip::getDebugRingBuffersStatusInternal,
292                          hidl_status_cb);
293 }
294 
startLoggingToDebugRingBuffer(const hidl_string & ring_name,WifiDebugRingBufferVerboseLevel verbose_level,uint32_t max_interval_in_sec,uint32_t min_data_size_in_bytes,startLoggingToDebugRingBuffer_cb hidl_status_cb)295 Return<void> WifiChip::startLoggingToDebugRingBuffer(
296     const hidl_string& ring_name,
297     WifiDebugRingBufferVerboseLevel verbose_level,
298     uint32_t max_interval_in_sec,
299     uint32_t min_data_size_in_bytes,
300     startLoggingToDebugRingBuffer_cb hidl_status_cb) {
301   return validateAndCall(this,
302                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
303                          &WifiChip::startLoggingToDebugRingBufferInternal,
304                          hidl_status_cb,
305                          ring_name,
306                          verbose_level,
307                          max_interval_in_sec,
308                          min_data_size_in_bytes);
309 }
310 
forceDumpToDebugRingBuffer(const hidl_string & ring_name,forceDumpToDebugRingBuffer_cb hidl_status_cb)311 Return<void> WifiChip::forceDumpToDebugRingBuffer(
312     const hidl_string& ring_name,
313     forceDumpToDebugRingBuffer_cb hidl_status_cb) {
314   return validateAndCall(this,
315                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
316                          &WifiChip::forceDumpToDebugRingBufferInternal,
317                          hidl_status_cb,
318                          ring_name);
319 }
320 
stopLoggingToDebugRingBuffer(stopLoggingToDebugRingBuffer_cb hidl_status_cb)321 Return<void> WifiChip::stopLoggingToDebugRingBuffer(
322     stopLoggingToDebugRingBuffer_cb hidl_status_cb) {
323   return validateAndCall(this,
324                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
325                          &WifiChip::stopLoggingToDebugRingBufferInternal,
326                          hidl_status_cb);
327 }
328 
getDebugHostWakeReasonStats(getDebugHostWakeReasonStats_cb hidl_status_cb)329 Return<void> WifiChip::getDebugHostWakeReasonStats(
330     getDebugHostWakeReasonStats_cb hidl_status_cb) {
331   return validateAndCall(this,
332                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
333                          &WifiChip::getDebugHostWakeReasonStatsInternal,
334                          hidl_status_cb);
335 }
336 
enableDebugErrorAlerts(bool enable,enableDebugErrorAlerts_cb hidl_status_cb)337 Return<void> WifiChip::enableDebugErrorAlerts(
338     bool enable, enableDebugErrorAlerts_cb hidl_status_cb) {
339   return validateAndCall(this,
340                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
341                          &WifiChip::enableDebugErrorAlertsInternal,
342                          hidl_status_cb,
343                          enable);
344 }
345 
invalidateAndRemoveAllIfaces()346 void WifiChip::invalidateAndRemoveAllIfaces() {
347   invalidateAndClear(ap_iface_);
348   invalidateAndClear(nan_iface_);
349   invalidateAndClear(p2p_iface_);
350   invalidateAndClear(sta_iface_);
351   // Since all the ifaces are invalid now, all RTT controller objects
352   // using those ifaces also need to be invalidated.
353   for (const auto& rtt : rtt_controllers_) {
354     rtt->invalidate();
355   }
356   rtt_controllers_.clear();
357 }
358 
getIdInternal()359 std::pair<WifiStatus, ChipId> WifiChip::getIdInternal() {
360   return {createWifiStatus(WifiStatusCode::SUCCESS), chip_id_};
361 }
362 
registerEventCallbackInternal(const sp<IWifiChipEventCallback> & event_callback)363 WifiStatus WifiChip::registerEventCallbackInternal(
364     const sp<IWifiChipEventCallback>& event_callback) {
365   if (!event_cb_handler_.addCallback(event_callback)) {
366     return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
367   }
368   return createWifiStatus(WifiStatusCode::SUCCESS);
369 }
370 
getCapabilitiesInternal()371 std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal() {
372   legacy_hal::wifi_error legacy_status;
373   uint32_t legacy_logger_feature_set;
374   std::tie(legacy_status, legacy_logger_feature_set) =
375       legacy_hal_.lock()->getLoggerSupportedFeatureSet();
376   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
377     return {createWifiStatusFromLegacyError(legacy_status), 0};
378   }
379   uint32_t hidl_caps;
380   if (!hidl_struct_util::convertLegacyFeaturesToHidlChipCapabilities(
381           legacy_logger_feature_set, &hidl_caps)) {
382     return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), 0};
383   }
384   return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
385 }
386 
387 std::pair<WifiStatus, std::vector<IWifiChip::ChipMode>>
getAvailableModesInternal()388 WifiChip::getAvailableModesInternal() {
389   // The chip combination supported for current devices is fixed for now with
390   // 2 separate modes of operation:
391   // Mode 1 (STA mode): Will support 1 STA and 1 P2P or NAN iface operations
392   // concurrently [NAN conditional on wifiHidlFeatureAware]
393   // Mode 2 (AP mode): Will support 1 AP iface operations.
394   // TODO (b/32997844): Read this from some device specific flags in the
395   // makefile.
396   // STA mode iface combinations.
397   const IWifiChip::ChipIfaceCombinationLimit
398       sta_chip_iface_combination_limit_1 = {{IfaceType::STA}, 1};
399   IWifiChip::ChipIfaceCombinationLimit sta_chip_iface_combination_limit_2;
400   if (WifiFeatureFlags::wifiHidlFeatureAware) {
401     sta_chip_iface_combination_limit_2 = {{IfaceType::P2P, IfaceType::NAN},
402                                           1};
403   } else {
404     sta_chip_iface_combination_limit_2 = {{IfaceType::P2P},
405                                           1};
406   }
407   const IWifiChip::ChipIfaceCombination sta_chip_iface_combination = {
408       {sta_chip_iface_combination_limit_1, sta_chip_iface_combination_limit_2}};
409   const IWifiChip::ChipMode sta_chip_mode = {kStaChipModeId,
410                                              {sta_chip_iface_combination}};
411   // AP mode iface combinations.
412   const IWifiChip::ChipIfaceCombinationLimit ap_chip_iface_combination_limit = {
413       {IfaceType::AP}, 1};
414   const IWifiChip::ChipIfaceCombination ap_chip_iface_combination = {
415       {ap_chip_iface_combination_limit}};
416   const IWifiChip::ChipMode ap_chip_mode = {kApChipModeId,
417                                             {ap_chip_iface_combination}};
418   return {createWifiStatus(WifiStatusCode::SUCCESS),
419           {sta_chip_mode, ap_chip_mode}};
420 }
421 
configureChipInternal(ChipModeId mode_id)422 WifiStatus WifiChip::configureChipInternal(ChipModeId mode_id) {
423   if (mode_id != kStaChipModeId && mode_id != kApChipModeId) {
424     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
425   }
426   if (mode_id == current_mode_id_) {
427     LOG(DEBUG) << "Already in the specified mode " << mode_id;
428     return createWifiStatus(WifiStatusCode::SUCCESS);
429   }
430   WifiStatus status = handleChipConfiguration(mode_id);
431   if (status.code != WifiStatusCode::SUCCESS) {
432     for (const auto& callback : event_cb_handler_.getCallbacks()) {
433       if (!callback->onChipReconfigureFailure(status).isOk()) {
434         LOG(ERROR) << "Failed to invoke onChipReconfigureFailure callback";
435       }
436     }
437     return status;
438   }
439   for (const auto& callback : event_cb_handler_.getCallbacks()) {
440     if (!callback->onChipReconfigured(mode_id).isOk()) {
441       LOG(ERROR) << "Failed to invoke onChipReconfigured callback";
442     }
443   }
444   current_mode_id_ = mode_id;
445   return status;
446 }
447 
getModeInternal()448 std::pair<WifiStatus, uint32_t> WifiChip::getModeInternal() {
449   if (current_mode_id_ == kInvalidModeId) {
450     return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE),
451             current_mode_id_};
452   }
453   return {createWifiStatus(WifiStatusCode::SUCCESS), current_mode_id_};
454 }
455 
456 std::pair<WifiStatus, IWifiChip::ChipDebugInfo>
requestChipDebugInfoInternal()457 WifiChip::requestChipDebugInfoInternal() {
458   IWifiChip::ChipDebugInfo result;
459   legacy_hal::wifi_error legacy_status;
460   std::string driver_desc;
461   std::tie(legacy_status, driver_desc) = legacy_hal_.lock()->getDriverVersion();
462   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
463     LOG(ERROR) << "Failed to get driver version: "
464                << legacyErrorToString(legacy_status);
465     WifiStatus status = createWifiStatusFromLegacyError(
466         legacy_status, "failed to get driver version");
467     return {status, result};
468   }
469   result.driverDescription = driver_desc.c_str();
470 
471   std::string firmware_desc;
472   std::tie(legacy_status, firmware_desc) =
473       legacy_hal_.lock()->getFirmwareVersion();
474   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
475     LOG(ERROR) << "Failed to get firmware version: "
476                << legacyErrorToString(legacy_status);
477     WifiStatus status = createWifiStatusFromLegacyError(
478         legacy_status, "failed to get firmware version");
479     return {status, result};
480   }
481   result.firmwareDescription = firmware_desc.c_str();
482 
483   return {createWifiStatus(WifiStatusCode::SUCCESS), result};
484 }
485 
486 std::pair<WifiStatus, std::vector<uint8_t>>
requestDriverDebugDumpInternal()487 WifiChip::requestDriverDebugDumpInternal() {
488   legacy_hal::wifi_error legacy_status;
489   std::vector<uint8_t> driver_dump;
490   std::tie(legacy_status, driver_dump) =
491       legacy_hal_.lock()->requestDriverMemoryDump();
492   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
493     LOG(ERROR) << "Failed to get driver debug dump: "
494                << legacyErrorToString(legacy_status);
495     return {createWifiStatusFromLegacyError(legacy_status),
496             std::vector<uint8_t>()};
497   }
498   return {createWifiStatus(WifiStatusCode::SUCCESS), driver_dump};
499 }
500 
501 std::pair<WifiStatus, std::vector<uint8_t>>
requestFirmwareDebugDumpInternal()502 WifiChip::requestFirmwareDebugDumpInternal() {
503   legacy_hal::wifi_error legacy_status;
504   std::vector<uint8_t> firmware_dump;
505   std::tie(legacy_status, firmware_dump) =
506       legacy_hal_.lock()->requestFirmwareMemoryDump();
507   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
508     LOG(ERROR) << "Failed to get firmware debug dump: "
509                << legacyErrorToString(legacy_status);
510     return {createWifiStatusFromLegacyError(legacy_status), {}};
511   }
512   return {createWifiStatus(WifiStatusCode::SUCCESS), firmware_dump};
513 }
514 
createApIfaceInternal()515 std::pair<WifiStatus, sp<IWifiApIface>> WifiChip::createApIfaceInternal() {
516   if (current_mode_id_ != kApChipModeId || ap_iface_.get()) {
517     return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
518   }
519   std::string ifname = legacy_hal_.lock()->getApIfaceName();
520   ap_iface_ = new WifiApIface(ifname, legacy_hal_);
521   for (const auto& callback : event_cb_handler_.getCallbacks()) {
522     if (!callback->onIfaceAdded(IfaceType::AP, ifname).isOk()) {
523       LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
524     }
525   }
526   return {createWifiStatus(WifiStatusCode::SUCCESS), ap_iface_};
527 }
528 
529 std::pair<WifiStatus, std::vector<hidl_string>>
getApIfaceNamesInternal()530 WifiChip::getApIfaceNamesInternal() {
531   if (!ap_iface_.get()) {
532     return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
533   }
534   return {createWifiStatus(WifiStatusCode::SUCCESS),
535           {legacy_hal_.lock()->getApIfaceName()}};
536 }
537 
getApIfaceInternal(const std::string & ifname)538 std::pair<WifiStatus, sp<IWifiApIface>> WifiChip::getApIfaceInternal(
539     const std::string& ifname) {
540   if (!ap_iface_.get() || (ifname != legacy_hal_.lock()->getApIfaceName())) {
541     return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
542   }
543   return {createWifiStatus(WifiStatusCode::SUCCESS), ap_iface_};
544 }
545 
removeApIfaceInternal(const std::string & ifname)546 WifiStatus WifiChip::removeApIfaceInternal(const std::string& ifname) {
547   if (!ap_iface_.get() || (ifname != legacy_hal_.lock()->getApIfaceName())) {
548     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
549   }
550   invalidateAndClear(ap_iface_);
551   for (const auto& callback : event_cb_handler_.getCallbacks()) {
552     if (!callback->onIfaceRemoved(IfaceType::AP, ifname).isOk()) {
553       LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
554     }
555   }
556   return createWifiStatus(WifiStatusCode::SUCCESS);
557 }
558 
createNanIfaceInternal()559 std::pair<WifiStatus, sp<IWifiNanIface>> WifiChip::createNanIfaceInternal() {
560   // Only 1 of NAN or P2P iface can be active at a time.
561   if (WifiFeatureFlags::wifiHidlFeatureAware) {
562     if (current_mode_id_ != kStaChipModeId || nan_iface_.get() ||
563         p2p_iface_.get()) {
564       return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
565     }
566     std::string ifname = legacy_hal_.lock()->getNanIfaceName();
567     nan_iface_ = new WifiNanIface(ifname, legacy_hal_);
568     for (const auto& callback : event_cb_handler_.getCallbacks()) {
569       if (!callback->onIfaceAdded(IfaceType::NAN, ifname).isOk()) {
570         LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
571       }
572     }
573     return {createWifiStatus(WifiStatusCode::SUCCESS), nan_iface_};
574   } else {
575     return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
576   }
577 }
578 
579 std::pair<WifiStatus, std::vector<hidl_string>>
getNanIfaceNamesInternal()580 WifiChip::getNanIfaceNamesInternal() {
581   if (!nan_iface_.get()) {
582     return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
583   }
584   return {createWifiStatus(WifiStatusCode::SUCCESS),
585           {legacy_hal_.lock()->getNanIfaceName()}};
586 }
587 
getNanIfaceInternal(const std::string & ifname)588 std::pair<WifiStatus, sp<IWifiNanIface>> WifiChip::getNanIfaceInternal(
589     const std::string& ifname) {
590   if (!nan_iface_.get() || (ifname != legacy_hal_.lock()->getNanIfaceName())) {
591     return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
592   }
593   return {createWifiStatus(WifiStatusCode::SUCCESS), nan_iface_};
594 }
595 
removeNanIfaceInternal(const std::string & ifname)596 WifiStatus WifiChip::removeNanIfaceInternal(const std::string& ifname) {
597   if (!nan_iface_.get() || (ifname != legacy_hal_.lock()->getNanIfaceName())) {
598     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
599   }
600   invalidateAndClear(nan_iface_);
601   for (const auto& callback : event_cb_handler_.getCallbacks()) {
602     if (!callback->onIfaceRemoved(IfaceType::NAN, ifname).isOk()) {
603       LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
604     }
605   }
606   return createWifiStatus(WifiStatusCode::SUCCESS);
607 }
608 
createP2pIfaceInternal()609 std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::createP2pIfaceInternal() {
610   // Only 1 of NAN or P2P iface can be active at a time.
611   if (current_mode_id_ != kStaChipModeId || p2p_iface_.get() ||
612       nan_iface_.get()) {
613     return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
614   }
615   std::string ifname = legacy_hal_.lock()->getP2pIfaceName();
616   p2p_iface_ = new WifiP2pIface(ifname, legacy_hal_);
617   for (const auto& callback : event_cb_handler_.getCallbacks()) {
618     if (!callback->onIfaceAdded(IfaceType::P2P, ifname).isOk()) {
619       LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
620     }
621   }
622   return {createWifiStatus(WifiStatusCode::SUCCESS), p2p_iface_};
623 }
624 
625 std::pair<WifiStatus, std::vector<hidl_string>>
getP2pIfaceNamesInternal()626 WifiChip::getP2pIfaceNamesInternal() {
627   if (!p2p_iface_.get()) {
628     return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
629   }
630   return {createWifiStatus(WifiStatusCode::SUCCESS),
631           {legacy_hal_.lock()->getP2pIfaceName()}};
632 }
633 
getP2pIfaceInternal(const std::string & ifname)634 std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::getP2pIfaceInternal(
635     const std::string& ifname) {
636   if (!p2p_iface_.get() || (ifname != legacy_hal_.lock()->getP2pIfaceName())) {
637     return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
638   }
639   return {createWifiStatus(WifiStatusCode::SUCCESS), p2p_iface_};
640 }
641 
removeP2pIfaceInternal(const std::string & ifname)642 WifiStatus WifiChip::removeP2pIfaceInternal(const std::string& ifname) {
643   if (!p2p_iface_.get() || (ifname != legacy_hal_.lock()->getP2pIfaceName())) {
644     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
645   }
646   invalidateAndClear(p2p_iface_);
647   for (const auto& callback : event_cb_handler_.getCallbacks()) {
648     if (!callback->onIfaceRemoved(IfaceType::P2P, ifname).isOk()) {
649       LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
650     }
651   }
652   return createWifiStatus(WifiStatusCode::SUCCESS);
653 }
654 
createStaIfaceInternal()655 std::pair<WifiStatus, sp<IWifiStaIface>> WifiChip::createStaIfaceInternal() {
656   if (current_mode_id_ != kStaChipModeId || sta_iface_.get()) {
657     return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
658   }
659   std::string ifname = legacy_hal_.lock()->getStaIfaceName();
660   sta_iface_ = new WifiStaIface(ifname, legacy_hal_);
661   for (const auto& callback : event_cb_handler_.getCallbacks()) {
662     if (!callback->onIfaceAdded(IfaceType::STA, ifname).isOk()) {
663       LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
664     }
665   }
666   return {createWifiStatus(WifiStatusCode::SUCCESS), sta_iface_};
667 }
668 
669 std::pair<WifiStatus, std::vector<hidl_string>>
getStaIfaceNamesInternal()670 WifiChip::getStaIfaceNamesInternal() {
671   if (!sta_iface_.get()) {
672     return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
673   }
674   return {createWifiStatus(WifiStatusCode::SUCCESS),
675           {legacy_hal_.lock()->getStaIfaceName()}};
676 }
677 
getStaIfaceInternal(const std::string & ifname)678 std::pair<WifiStatus, sp<IWifiStaIface>> WifiChip::getStaIfaceInternal(
679     const std::string& ifname) {
680   if (!sta_iface_.get() || (ifname != legacy_hal_.lock()->getStaIfaceName())) {
681     return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
682   }
683   return {createWifiStatus(WifiStatusCode::SUCCESS), sta_iface_};
684 }
685 
removeStaIfaceInternal(const std::string & ifname)686 WifiStatus WifiChip::removeStaIfaceInternal(const std::string& ifname) {
687   if (!sta_iface_.get() || (ifname != legacy_hal_.lock()->getStaIfaceName())) {
688     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
689   }
690   invalidateAndClear(sta_iface_);
691   for (const auto& callback : event_cb_handler_.getCallbacks()) {
692     if (!callback->onIfaceRemoved(IfaceType::STA, ifname).isOk()) {
693       LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
694     }
695   }
696   return createWifiStatus(WifiStatusCode::SUCCESS);
697 }
698 
699 std::pair<WifiStatus, sp<IWifiRttController>>
createRttControllerInternal(const sp<IWifiIface> & bound_iface)700 WifiChip::createRttControllerInternal(const sp<IWifiIface>& bound_iface) {
701   sp<WifiRttController> rtt = new WifiRttController(bound_iface, legacy_hal_);
702   rtt_controllers_.emplace_back(rtt);
703   return {createWifiStatus(WifiStatusCode::SUCCESS), rtt};
704 }
705 
706 std::pair<WifiStatus, std::vector<WifiDebugRingBufferStatus>>
getDebugRingBuffersStatusInternal()707 WifiChip::getDebugRingBuffersStatusInternal() {
708   legacy_hal::wifi_error legacy_status;
709   std::vector<legacy_hal::wifi_ring_buffer_status>
710       legacy_ring_buffer_status_vec;
711   std::tie(legacy_status, legacy_ring_buffer_status_vec) =
712       legacy_hal_.lock()->getRingBuffersStatus();
713   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
714     return {createWifiStatusFromLegacyError(legacy_status), {}};
715   }
716   std::vector<WifiDebugRingBufferStatus> hidl_ring_buffer_status_vec;
717   if (!hidl_struct_util::convertLegacyVectorOfDebugRingBufferStatusToHidl(
718           legacy_ring_buffer_status_vec, &hidl_ring_buffer_status_vec)) {
719     return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
720   }
721   return {createWifiStatus(WifiStatusCode::SUCCESS),
722           hidl_ring_buffer_status_vec};
723 }
724 
startLoggingToDebugRingBufferInternal(const hidl_string & ring_name,WifiDebugRingBufferVerboseLevel verbose_level,uint32_t max_interval_in_sec,uint32_t min_data_size_in_bytes)725 WifiStatus WifiChip::startLoggingToDebugRingBufferInternal(
726     const hidl_string& ring_name,
727     WifiDebugRingBufferVerboseLevel verbose_level,
728     uint32_t max_interval_in_sec,
729     uint32_t min_data_size_in_bytes) {
730   WifiStatus status = registerDebugRingBufferCallback();
731   if (status.code != WifiStatusCode::SUCCESS) {
732     return status;
733   }
734   legacy_hal::wifi_error legacy_status =
735       legacy_hal_.lock()->startRingBufferLogging(
736           ring_name,
737           static_cast<
738               std::underlying_type<WifiDebugRingBufferVerboseLevel>::type>(
739               verbose_level),
740           max_interval_in_sec,
741           min_data_size_in_bytes);
742   return createWifiStatusFromLegacyError(legacy_status);
743 }
744 
forceDumpToDebugRingBufferInternal(const hidl_string & ring_name)745 WifiStatus WifiChip::forceDumpToDebugRingBufferInternal(
746     const hidl_string& ring_name) {
747   WifiStatus status = registerDebugRingBufferCallback();
748   if (status.code != WifiStatusCode::SUCCESS) {
749     return status;
750   }
751   legacy_hal::wifi_error legacy_status =
752       legacy_hal_.lock()->getRingBufferData(ring_name);
753   return createWifiStatusFromLegacyError(legacy_status);
754 }
755 
stopLoggingToDebugRingBufferInternal()756 WifiStatus WifiChip::stopLoggingToDebugRingBufferInternal() {
757   legacy_hal::wifi_error legacy_status =
758       legacy_hal_.lock()->deregisterRingBufferCallbackHandler();
759   return createWifiStatusFromLegacyError(legacy_status);
760 }
761 
762 std::pair<WifiStatus, WifiDebugHostWakeReasonStats>
getDebugHostWakeReasonStatsInternal()763 WifiChip::getDebugHostWakeReasonStatsInternal() {
764   legacy_hal::wifi_error legacy_status;
765   legacy_hal::WakeReasonStats legacy_stats;
766   std::tie(legacy_status, legacy_stats) =
767       legacy_hal_.lock()->getWakeReasonStats();
768   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
769     return {createWifiStatusFromLegacyError(legacy_status), {}};
770   }
771   WifiDebugHostWakeReasonStats hidl_stats;
772   if (!hidl_struct_util::convertLegacyWakeReasonStatsToHidl(legacy_stats,
773                                                             &hidl_stats)) {
774     return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
775   }
776   return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_stats};
777 }
778 
enableDebugErrorAlertsInternal(bool enable)779 WifiStatus WifiChip::enableDebugErrorAlertsInternal(bool enable) {
780   legacy_hal::wifi_error legacy_status;
781   if (enable) {
782     android::wp<WifiChip> weak_ptr_this(this);
783     const auto& on_alert_callback = [weak_ptr_this](
784         int32_t error_code, std::vector<uint8_t> debug_data) {
785       const auto shared_ptr_this = weak_ptr_this.promote();
786       if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
787         LOG(ERROR) << "Callback invoked on an invalid object";
788         return;
789       }
790       for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
791         if (!callback->onDebugErrorAlert(error_code, debug_data).isOk()) {
792           LOG(ERROR) << "Failed to invoke onDebugErrorAlert callback";
793         }
794       }
795     };
796     legacy_status = legacy_hal_.lock()->registerErrorAlertCallbackHandler(
797         on_alert_callback);
798   } else {
799     legacy_status = legacy_hal_.lock()->deregisterErrorAlertCallbackHandler();
800   }
801   return createWifiStatusFromLegacyError(legacy_status);
802 }
803 
handleChipConfiguration(ChipModeId mode_id)804 WifiStatus WifiChip::handleChipConfiguration(ChipModeId mode_id) {
805   // If the chip is already configured in a different mode, stop
806   // the legacy HAL and then start it after firmware mode change.
807   // Currently the underlying implementation has a deadlock issue.
808   // We should return ERROR_NOT_SUPPORTED if chip is already configured in
809   // a different mode.
810   if (current_mode_id_ != kInvalidModeId) {
811     // TODO(b/37446050): Fix the deadlock.
812     return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
813   }
814   bool success;
815   if (mode_id == kStaChipModeId) {
816     success = mode_controller_.lock()->changeFirmwareMode(IfaceType::STA);
817   } else {
818     success = mode_controller_.lock()->changeFirmwareMode(IfaceType::AP);
819   }
820   if (!success) {
821     return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
822   }
823   legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->start();
824   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
825     LOG(ERROR) << "Failed to start legacy HAL: "
826                << legacyErrorToString(legacy_status);
827     return createWifiStatusFromLegacyError(legacy_status);
828   }
829   return createWifiStatus(WifiStatusCode::SUCCESS);
830 }
831 
registerDebugRingBufferCallback()832 WifiStatus WifiChip::registerDebugRingBufferCallback() {
833   if (debug_ring_buffer_cb_registered_) {
834     return createWifiStatus(WifiStatusCode::SUCCESS);
835   }
836 
837   android::wp<WifiChip> weak_ptr_this(this);
838   const auto& on_ring_buffer_data_callback = [weak_ptr_this](
839       const std::string& /* name */,
840       const std::vector<uint8_t>& data,
841       const legacy_hal::wifi_ring_buffer_status& status) {
842     const auto shared_ptr_this = weak_ptr_this.promote();
843     if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
844       LOG(ERROR) << "Callback invoked on an invalid object";
845       return;
846     }
847     WifiDebugRingBufferStatus hidl_status;
848     if (!hidl_struct_util::convertLegacyDebugRingBufferStatusToHidl(
849             status, &hidl_status)) {
850       LOG(ERROR) << "Error converting ring buffer status";
851       return;
852     }
853     for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
854       if (!callback->onDebugRingBufferDataAvailable(hidl_status, data).isOk()) {
855         LOG(ERROR) << "Failed to invoke onDebugRingBufferDataAvailable"
856                    << " callback on: " << toString(callback);
857 
858       }
859     }
860   };
861   legacy_hal::wifi_error legacy_status =
862       legacy_hal_.lock()->registerRingBufferCallbackHandler(
863           on_ring_buffer_data_callback);
864 
865   if (legacy_status == legacy_hal::WIFI_SUCCESS) {
866     debug_ring_buffer_cb_registered_ = true;
867   }
868   return createWifiStatusFromLegacyError(legacy_status);
869 }
870 
871 }  // namespace implementation
872 }  // namespace V1_0
873 }  // namespace wifi
874 }  // namespace hardware
875 }  // namespace android
876