blob: 5613357a71bb90c4686475001160c30083dd1793 [file] [log] [blame]
Roshan Piuse65edb12016-11-22 13:02:01 -08001/*
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#include <utils/SystemClock.h>
19
20#include "hidl_struct_util.h"
21
22namespace android {
23namespace hardware {
24namespace wifi {
Jimmy Chend460df32019-11-29 17:31:22 +020025namespace V1_5 {
Roshan Piuse65edb12016-11-22 13:02:01 -080026namespace implementation {
27namespace hidl_struct_util {
28
Etan Cohenb1b7a822018-02-07 14:44:32 -080029WifiChannelWidthInMhz convertLegacyWifiChannelWidthToHidl(
30 legacy_hal::wifi_channel_width type);
31
Etan Cohenbbc0f092017-04-26 16:52:34 -070032hidl_string safeConvertChar(const char* str, size_t max_len) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070033 const char* c = str;
34 size_t size = 0;
35 while (*c && (unsigned char)*c < 128 && size < max_len) {
36 ++size;
37 ++c;
38 }
39 return hidl_string(str, size);
Etan Cohenbbc0f092017-04-26 16:52:34 -070040}
41
Roshan Piusf72df2e2016-12-04 10:49:38 -080042IWifiChip::ChipCapabilityMask convertLegacyLoggerFeatureToHidlChipCapability(
43 uint32_t feature) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070044 using HidlChipCaps = IWifiChip::ChipCapabilityMask;
45 switch (feature) {
46 case legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED:
47 return HidlChipCaps::DEBUG_MEMORY_FIRMWARE_DUMP;
48 case legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED:
49 return HidlChipCaps::DEBUG_MEMORY_DRIVER_DUMP;
50 case legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED:
51 return HidlChipCaps::DEBUG_RING_BUFFER_CONNECT_EVENT;
52 case legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED:
53 return HidlChipCaps::DEBUG_RING_BUFFER_POWER_EVENT;
54 case legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED:
55 return HidlChipCaps::DEBUG_RING_BUFFER_WAKELOCK_EVENT;
56 };
57 CHECK(false) << "Unknown legacy feature: " << feature;
58 return {};
Roshan Piusf72df2e2016-12-04 10:49:38 -080059}
60
61IWifiStaIface::StaIfaceCapabilityMask
62convertLegacyLoggerFeatureToHidlStaIfaceCapability(uint32_t feature) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070063 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
64 switch (feature) {
65 case legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED:
66 return HidlStaIfaceCaps::DEBUG_PACKET_FATE;
67 };
68 CHECK(false) << "Unknown legacy feature: " << feature;
69 return {};
Roshan Piusf72df2e2016-12-04 10:49:38 -080070}
71
Jimmy Chen1bdf1a72019-12-23 17:53:40 +020072V1_5::IWifiChip::ChipCapabilityMask convertLegacyFeatureToHidlChipCapability(
73 uint64_t feature) {
74 using HidlChipCaps = V1_5::IWifiChip::ChipCapabilityMask;
Roshan Piusabcf78f2017-10-06 16:30:38 -070075 switch (feature) {
76 case WIFI_FEATURE_SET_TX_POWER_LIMIT:
77 return HidlChipCaps::SET_TX_POWER_LIMIT;
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -080078 case WIFI_FEATURE_USE_BODY_HEAD_SAR:
79 return HidlChipCaps::USE_BODY_HEAD_SAR;
Roshan Piusabcf78f2017-10-06 16:30:38 -070080 case WIFI_FEATURE_D2D_RTT:
81 return HidlChipCaps::D2D_RTT;
82 case WIFI_FEATURE_D2AP_RTT:
83 return HidlChipCaps::D2AP_RTT;
Jimmy Chen1bdf1a72019-12-23 17:53:40 +020084 case WIFI_FEATURE_INFRA_60G:
85 return HidlChipCaps::WIGIG;
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -070086 case WIFI_FEATURE_SET_LATENCY_MODE:
87 return HidlChipCaps::SET_LATENCY_MODE;
Jimmy Chend87a0ee2018-12-14 15:38:58 +080088 case WIFI_FEATURE_P2P_RAND_MAC:
89 return HidlChipCaps::P2P_RAND_MAC;
Roshan Piusabcf78f2017-10-06 16:30:38 -070090 };
91 CHECK(false) << "Unknown legacy feature: " << feature;
92 return {};
Roshan Pius8184d212017-07-11 08:59:29 -070093}
94
Roshan Piusf72df2e2016-12-04 10:49:38 -080095IWifiStaIface::StaIfaceCapabilityMask
Ahmed ElArabawy95e36b72019-11-15 21:24:53 +000096convertLegacyFeatureToHidlStaIfaceCapability(uint64_t feature) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070097 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
98 switch (feature) {
99 case WIFI_FEATURE_GSCAN:
100 return HidlStaIfaceCaps::BACKGROUND_SCAN;
101 case WIFI_FEATURE_LINK_LAYER_STATS:
102 return HidlStaIfaceCaps::LINK_LAYER_STATS;
103 case WIFI_FEATURE_RSSI_MONITOR:
104 return HidlStaIfaceCaps::RSSI_MONITOR;
105 case WIFI_FEATURE_CONTROL_ROAMING:
106 return HidlStaIfaceCaps::CONTROL_ROAMING;
107 case WIFI_FEATURE_IE_WHITELIST:
108 return HidlStaIfaceCaps::PROBE_IE_WHITELIST;
109 case WIFI_FEATURE_SCAN_RAND:
110 return HidlStaIfaceCaps::SCAN_RAND;
111 case WIFI_FEATURE_INFRA_5G:
112 return HidlStaIfaceCaps::STA_5G;
113 case WIFI_FEATURE_HOTSPOT:
114 return HidlStaIfaceCaps::HOTSPOT;
115 case WIFI_FEATURE_PNO:
116 return HidlStaIfaceCaps::PNO;
117 case WIFI_FEATURE_TDLS:
118 return HidlStaIfaceCaps::TDLS;
119 case WIFI_FEATURE_TDLS_OFFCHANNEL:
120 return HidlStaIfaceCaps::TDLS_OFFCHANNEL;
121 case WIFI_FEATURE_CONFIG_NDO:
122 return HidlStaIfaceCaps::ND_OFFLOAD;
123 case WIFI_FEATURE_MKEEP_ALIVE:
124 return HidlStaIfaceCaps::KEEP_ALIVE;
125 };
126 CHECK(false) << "Unknown legacy feature: " << feature;
127 return {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800128}
129
130bool convertLegacyFeaturesToHidlChipCapabilities(
Jimmy Chen1bdf1a72019-12-23 17:53:40 +0200131 uint64_t legacy_feature_set, uint32_t legacy_logger_feature_set,
Roshan Pius8184d212017-07-11 08:59:29 -0700132 uint32_t* hidl_caps) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700133 if (!hidl_caps) {
134 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800135 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700136 *hidl_caps = {};
137 using HidlChipCaps = IWifiChip::ChipCapabilityMask;
138 for (const auto feature : {legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED,
139 legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED,
140 legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED,
141 legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED,
142 legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED}) {
143 if (feature & legacy_logger_feature_set) {
144 *hidl_caps |=
145 convertLegacyLoggerFeatureToHidlChipCapability(feature);
146 }
Roshan Pius8184d212017-07-11 08:59:29 -0700147 }
Jimmy Chen1bdf1a72019-12-23 17:53:40 +0200148 std::vector<uint64_t> features = {WIFI_FEATURE_SET_TX_POWER_LIMIT,
Jimmy Chend87a0ee2018-12-14 15:38:58 +0800149 WIFI_FEATURE_USE_BODY_HEAD_SAR,
150 WIFI_FEATURE_D2D_RTT,
151 WIFI_FEATURE_D2AP_RTT,
Jimmy Chen1bdf1a72019-12-23 17:53:40 +0200152 WIFI_FEATURE_INFRA_60G,
Jimmy Chend87a0ee2018-12-14 15:38:58 +0800153 WIFI_FEATURE_SET_LATENCY_MODE,
154 WIFI_FEATURE_P2P_RAND_MAC};
155 for (const auto feature : features) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700156 if (feature & legacy_feature_set) {
157 *hidl_caps |= convertLegacyFeatureToHidlChipCapability(feature);
158 }
159 }
Jimmy Chend87a0ee2018-12-14 15:38:58 +0800160
Roshan Piusabcf78f2017-10-06 16:30:38 -0700161 // There are no flags for these 3 in the legacy feature set. Adding them to
162 // the set because all the current devices support it.
163 *hidl_caps |= HidlChipCaps::DEBUG_RING_BUFFER_VENDOR_DATA;
164 *hidl_caps |= HidlChipCaps::DEBUG_HOST_WAKE_REASON_STATS;
165 *hidl_caps |= HidlChipCaps::DEBUG_ERROR_ALERTS;
166 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800167}
168
169WifiDebugRingBufferFlags convertLegacyDebugRingBufferFlagsToHidl(
170 uint32_t flag) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700171 switch (flag) {
172 case WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES:
173 return WifiDebugRingBufferFlags::HAS_BINARY_ENTRIES;
174 case WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES:
175 return WifiDebugRingBufferFlags::HAS_ASCII_ENTRIES;
176 };
177 CHECK(false) << "Unknown legacy flag: " << flag;
178 return {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800179}
180
181bool convertLegacyDebugRingBufferStatusToHidl(
182 const legacy_hal::wifi_ring_buffer_status& legacy_status,
183 WifiDebugRingBufferStatus* hidl_status) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700184 if (!hidl_status) {
185 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800186 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700187 *hidl_status = {};
188 hidl_status->ringName =
189 safeConvertChar(reinterpret_cast<const char*>(legacy_status.name),
190 sizeof(legacy_status.name));
191 hidl_status->flags = 0;
192 for (const auto flag : {WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES,
193 WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES}) {
194 if (flag & legacy_status.flags) {
195 hidl_status->flags |= static_cast<
196 std::underlying_type<WifiDebugRingBufferFlags>::type>(
197 convertLegacyDebugRingBufferFlagsToHidl(flag));
198 }
199 }
200 hidl_status->ringId = legacy_status.ring_id;
201 hidl_status->sizeInBytes = legacy_status.ring_buffer_byte_size;
202 // Calculate free size of the ring the buffer. We don't need to send the
203 // exact read/write pointers that were there in the legacy HAL interface.
204 if (legacy_status.written_bytes >= legacy_status.read_bytes) {
205 hidl_status->freeSizeInBytes =
206 legacy_status.ring_buffer_byte_size -
207 (legacy_status.written_bytes - legacy_status.read_bytes);
208 } else {
209 hidl_status->freeSizeInBytes =
210 legacy_status.read_bytes - legacy_status.written_bytes;
211 }
212 hidl_status->verboseLevel = legacy_status.verbose_level;
213 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800214}
215
216bool convertLegacyVectorOfDebugRingBufferStatusToHidl(
217 const std::vector<legacy_hal::wifi_ring_buffer_status>& legacy_status_vec,
218 std::vector<WifiDebugRingBufferStatus>* hidl_status_vec) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700219 if (!hidl_status_vec) {
220 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800221 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700222 *hidl_status_vec = {};
223 for (const auto& legacy_status : legacy_status_vec) {
224 WifiDebugRingBufferStatus hidl_status;
225 if (!convertLegacyDebugRingBufferStatusToHidl(legacy_status,
226 &hidl_status)) {
227 return false;
228 }
229 hidl_status_vec->push_back(hidl_status);
230 }
231 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800232}
233
234bool convertLegacyWakeReasonStatsToHidl(
235 const legacy_hal::WakeReasonStats& legacy_stats,
236 WifiDebugHostWakeReasonStats* hidl_stats) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700237 if (!hidl_stats) {
238 return false;
239 }
240 *hidl_stats = {};
241 hidl_stats->totalCmdEventWakeCnt =
242 legacy_stats.wake_reason_cnt.total_cmd_event_wake;
243 hidl_stats->cmdEventWakeCntPerType = legacy_stats.cmd_event_wake_cnt;
244 hidl_stats->totalDriverFwLocalWakeCnt =
245 legacy_stats.wake_reason_cnt.total_driver_fw_local_wake;
246 hidl_stats->driverFwLocalWakeCntPerType =
247 legacy_stats.driver_fw_local_wake_cnt;
248 hidl_stats->totalRxPacketWakeCnt =
249 legacy_stats.wake_reason_cnt.total_rx_data_wake;
250 hidl_stats->rxPktWakeDetails.rxUnicastCnt =
251 legacy_stats.wake_reason_cnt.rx_wake_details.rx_unicast_cnt;
252 hidl_stats->rxPktWakeDetails.rxMulticastCnt =
253 legacy_stats.wake_reason_cnt.rx_wake_details.rx_multicast_cnt;
254 hidl_stats->rxPktWakeDetails.rxBroadcastCnt =
255 legacy_stats.wake_reason_cnt.rx_wake_details.rx_broadcast_cnt;
256 hidl_stats->rxMulticastPkWakeDetails.ipv4RxMulticastAddrCnt =
257 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
258 .ipv4_rx_multicast_addr_cnt;
259 hidl_stats->rxMulticastPkWakeDetails.ipv6RxMulticastAddrCnt =
260 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
261 .ipv6_rx_multicast_addr_cnt;
262 hidl_stats->rxMulticastPkWakeDetails.otherRxMulticastAddrCnt =
263 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
264 .other_rx_multicast_addr_cnt;
265 hidl_stats->rxIcmpPkWakeDetails.icmpPkt =
266 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp_pkt;
267 hidl_stats->rxIcmpPkWakeDetails.icmp6Pkt =
268 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_pkt;
269 hidl_stats->rxIcmpPkWakeDetails.icmp6Ra =
270 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ra;
271 hidl_stats->rxIcmpPkWakeDetails.icmp6Na =
272 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_na;
273 hidl_stats->rxIcmpPkWakeDetails.icmp6Ns =
274 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ns;
275 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800276}
277
Roshan Pius735ff432017-07-25 08:48:08 -0700278legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy(
279 V1_1::IWifiChip::TxPowerScenario hidl_scenario) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700280 switch (hidl_scenario) {
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800281 // This is the only supported scenario for V1_1
Jong Wook Kimda830c92018-07-23 15:29:38 -0700282 case V1_1::IWifiChip::TxPowerScenario::VOICE_CALL:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700283 return legacy_hal::WIFI_POWER_SCENARIO_VOICE_CALL;
284 };
285 CHECK(false);
Roshan Pius735ff432017-07-25 08:48:08 -0700286}
287
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800288legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy_1_2(
Jong Wook Kimda830c92018-07-23 15:29:38 -0700289 V1_2::IWifiChip::TxPowerScenario hidl_scenario) {
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800290 switch (hidl_scenario) {
291 // This is the only supported scenario for V1_1
Jong Wook Kimda830c92018-07-23 15:29:38 -0700292 case V1_2::IWifiChip::TxPowerScenario::VOICE_CALL:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800293 return legacy_hal::WIFI_POWER_SCENARIO_VOICE_CALL;
294 // Those are the supported scenarios for V1_2
Jong Wook Kimda830c92018-07-23 15:29:38 -0700295 case V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800296 return legacy_hal::WIFI_POWER_SCENARIO_ON_HEAD_CELL_OFF;
Jong Wook Kimda830c92018-07-23 15:29:38 -0700297 case V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_ON:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800298 return legacy_hal::WIFI_POWER_SCENARIO_ON_HEAD_CELL_ON;
Jong Wook Kimda830c92018-07-23 15:29:38 -0700299 case V1_2::IWifiChip::TxPowerScenario::ON_BODY_CELL_OFF:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800300 return legacy_hal::WIFI_POWER_SCENARIO_ON_BODY_CELL_OFF;
Jong Wook Kimda830c92018-07-23 15:29:38 -0700301 case V1_2::IWifiChip::TxPowerScenario::ON_BODY_CELL_ON:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800302 return legacy_hal::WIFI_POWER_SCENARIO_ON_BODY_CELL_ON;
303 };
304 CHECK(false);
305}
306
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700307legacy_hal::wifi_latency_mode convertHidlLatencyModeToLegacy(
Ahmed ElArabawyf501a982019-07-23 15:02:22 -0700308 V1_3::IWifiChip::LatencyMode hidl_latency_mode) {
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700309 switch (hidl_latency_mode) {
Ahmed ElArabawyf501a982019-07-23 15:02:22 -0700310 case V1_3::IWifiChip::LatencyMode::NORMAL:
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700311 return legacy_hal::WIFI_LATENCY_MODE_NORMAL;
Ahmed ElArabawyf501a982019-07-23 15:02:22 -0700312 case V1_3::IWifiChip::LatencyMode::LOW:
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700313 return legacy_hal::WIFI_LATENCY_MODE_LOW;
314 }
315 CHECK(false);
316}
317
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800318bool convertLegacyWifiMacInfoToHidl(
319 const legacy_hal::WifiMacInfo& legacy_mac_info,
Jimmy Chend460df32019-11-29 17:31:22 +0200320 V1_4::IWifiChipEventCallback::RadioModeInfo* hidl_radio_mode_info) {
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800321 if (!hidl_radio_mode_info) {
322 return false;
323 }
324 *hidl_radio_mode_info = {};
325
326 hidl_radio_mode_info->radioId = legacy_mac_info.wlan_mac_id;
327 // Convert from bitmask of bands in the legacy HAL to enum value in
328 // the HIDL interface.
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800329 if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND &&
330 legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND &&
331 legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND) {
Jimmy Chend460df32019-11-29 17:31:22 +0200332 hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_24GHZ_5GHZ_6GHZ;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800333 } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND &&
334 legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
Jimmy Chend460df32019-11-29 17:31:22 +0200335 hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_5GHZ_6GHZ;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800336 } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND) {
Jimmy Chend460df32019-11-29 17:31:22 +0200337 hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_6GHZ;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800338 } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND &&
339 legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
Jimmy Chend460df32019-11-29 17:31:22 +0200340 hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_24GHZ_5GHZ;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800341 } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND) {
Jimmy Chend460df32019-11-29 17:31:22 +0200342 hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_24GHZ;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800343 } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
Jimmy Chend460df32019-11-29 17:31:22 +0200344 hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_5GHZ;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800345 } else {
Jimmy Chend460df32019-11-29 17:31:22 +0200346 hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_UNSPECIFIED;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800347 }
Jong Wook Kimda830c92018-07-23 15:29:38 -0700348 std::vector<V1_2::IWifiChipEventCallback::IfaceInfo> iface_info_vec;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800349 for (const auto& legacy_iface_info : legacy_mac_info.iface_infos) {
Jong Wook Kimda830c92018-07-23 15:29:38 -0700350 V1_2::IWifiChipEventCallback::IfaceInfo iface_info;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800351 iface_info.name = legacy_iface_info.name;
352 iface_info.channel = legacy_iface_info.channel;
353 iface_info_vec.push_back(iface_info);
354 }
355 hidl_radio_mode_info->ifaceInfos = iface_info_vec;
356 return true;
357}
358
Kumar Anand2a630a32021-01-21 14:09:14 -0800359uint32_t convertHidlWifiBandToLegacyMacBand(V1_5::WifiBand hidl_band) {
360 switch (hidl_band) {
361 case V1_5::WifiBand::BAND_24GHZ:
362 return legacy_hal::WLAN_MAC_2_4_BAND;
363 case V1_5::WifiBand::BAND_5GHZ:
364 case V1_5::WifiBand::BAND_5GHZ_DFS:
365 case V1_5::WifiBand::BAND_5GHZ_WITH_DFS:
366 return legacy_hal::WLAN_MAC_5_0_BAND;
367 case V1_5::WifiBand::BAND_24GHZ_5GHZ:
368 case V1_5::WifiBand::BAND_24GHZ_5GHZ_WITH_DFS:
369 return (legacy_hal::WLAN_MAC_2_4_BAND |
370 legacy_hal::WLAN_MAC_5_0_BAND);
371 case V1_5::WifiBand::BAND_6GHZ:
372 return legacy_hal::WLAN_MAC_6_0_BAND;
373 case V1_5::WifiBand::BAND_5GHZ_6GHZ:
374 return (legacy_hal::WLAN_MAC_5_0_BAND |
375 legacy_hal::WLAN_MAC_6_0_BAND);
376 case V1_5::WifiBand::BAND_24GHZ_5GHZ_6GHZ:
377 case V1_5::WifiBand::BAND_24GHZ_5GHZ_WITH_DFS_6GHZ:
378 return (legacy_hal::WLAN_MAC_2_4_BAND |
379 legacy_hal::WLAN_MAC_5_0_BAND |
380 legacy_hal::WLAN_MAC_6_0_BAND);
381 case V1_5::WifiBand::BAND_60GHZ:
382 return legacy_hal::WLAN_MAC_60_0_BAND;
383 default:
384 return (
385 legacy_hal::WLAN_MAC_2_4_BAND | legacy_hal::WLAN_MAC_5_0_BAND |
386 legacy_hal::WLAN_MAC_6_0_BAND | legacy_hal::WLAN_MAC_60_0_BAND);
387 }
388}
389
390uint32_t convertHidlWifiIfaceModeToLegacy(uint32_t hidl_iface_mask) {
391 uint32_t legacy_iface_mask = 0;
392 if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_STA) {
393 legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_STA);
394 }
395 if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_SOFTAP) {
396 legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_SOFTAP);
397 }
398 if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_P2P_CLIENT) {
399 legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_P2P_CLIENT);
400 }
401 if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_P2P_GO) {
402 legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_P2P_GO);
403 }
404 if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_NAN) {
405 legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_NAN);
406 }
407 if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_TDLS) {
408 legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_TDLS);
409 }
410 if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_MESH) {
411 legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_MESH);
412 }
413 if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_IBSS) {
414 legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_IBSS);
415 }
416 return legacy_iface_mask;
417}
418
419uint32_t convertLegacyWifiInterfaceModeToHidl(uint32_t legacy_iface_mask) {
420 uint32_t hidl_iface_mask = 0;
421 if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_STA)) {
422 hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_STA;
423 }
424 if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_SOFTAP)) {
425 hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_SOFTAP;
426 }
427 if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_P2P_CLIENT)) {
428 hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_P2P_CLIENT;
429 }
430 if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_P2P_GO)) {
431 hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_P2P_GO;
432 }
433 if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_NAN)) {
434 hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_NAN;
435 }
436 if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_TDLS)) {
437 hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_TDLS;
438 }
439 if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_MESH)) {
440 hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_MESH;
441 }
442 if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_IBSS)) {
443 hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_IBSS;
444 }
445 return hidl_iface_mask;
446}
447
448bool convertLegacyWifiUsableChannelToHidl(
449 const legacy_hal::wifi_usable_channel& legacy_usable_channel,
450 V1_5::WifiUsableChannel* hidl_usable_channel) {
451 if (!hidl_usable_channel) {
452 return false;
453 }
454 *hidl_usable_channel = {};
455 hidl_usable_channel->channel = legacy_usable_channel.freq;
456 hidl_usable_channel->channelBandwidth =
457 convertLegacyWifiChannelWidthToHidl(legacy_usable_channel.width);
458 hidl_usable_channel->ifaceModeMask = convertLegacyWifiInterfaceModeToHidl(
459 legacy_usable_channel.iface_mode_mask);
460
461 return true;
462}
463
464bool convertLegacyWifiUsableChannelsToHidl(
465 const std::vector<legacy_hal::wifi_usable_channel>& legacy_usable_channels,
466 std::vector<V1_5::WifiUsableChannel>* hidl_usable_channels) {
467 if (!hidl_usable_channels) {
468 return false;
469 }
470 *hidl_usable_channels = {};
471 for (const auto& legacy_usable_channel : legacy_usable_channels) {
472 V1_5::WifiUsableChannel hidl_usable_channel;
473 if (!convertLegacyWifiUsableChannelToHidl(legacy_usable_channel,
474 &hidl_usable_channel)) {
475 return false;
476 }
477 hidl_usable_channels->push_back(hidl_usable_channel);
478 }
479 return true;
480}
481
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800482bool convertLegacyWifiMacInfosToHidl(
483 const std::vector<legacy_hal::WifiMacInfo>& legacy_mac_infos,
Jimmy Chend460df32019-11-29 17:31:22 +0200484 std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo>*
485 hidl_radio_mode_infos) {
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800486 if (!hidl_radio_mode_infos) {
487 return false;
488 }
489 *hidl_radio_mode_infos = {};
490
491 for (const auto& legacy_mac_info : legacy_mac_infos) {
Jimmy Chend460df32019-11-29 17:31:22 +0200492 V1_4::IWifiChipEventCallback::RadioModeInfo hidl_radio_mode_info;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800493 if (!convertLegacyWifiMacInfoToHidl(legacy_mac_info,
494 &hidl_radio_mode_info)) {
495 return false;
496 }
497 hidl_radio_mode_infos->push_back(hidl_radio_mode_info);
498 }
499 return true;
500}
501
Roshan Piusf72df2e2016-12-04 10:49:38 -0800502bool convertLegacyFeaturesToHidlStaCapabilities(
Ahmed ElArabawy95e36b72019-11-15 21:24:53 +0000503 uint64_t legacy_feature_set, uint32_t legacy_logger_feature_set,
Roshan Piusf72df2e2016-12-04 10:49:38 -0800504 uint32_t* hidl_caps) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700505 if (!hidl_caps) {
506 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800507 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700508 *hidl_caps = {};
509 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
510 for (const auto feature : {legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED}) {
511 if (feature & legacy_logger_feature_set) {
512 *hidl_caps |=
513 convertLegacyLoggerFeatureToHidlStaIfaceCapability(feature);
514 }
Roshan Piusf72df2e2016-12-04 10:49:38 -0800515 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700516 for (const auto feature :
517 {WIFI_FEATURE_GSCAN, WIFI_FEATURE_LINK_LAYER_STATS,
518 WIFI_FEATURE_RSSI_MONITOR, WIFI_FEATURE_CONTROL_ROAMING,
519 WIFI_FEATURE_IE_WHITELIST, WIFI_FEATURE_SCAN_RAND,
520 WIFI_FEATURE_INFRA_5G, WIFI_FEATURE_HOTSPOT, WIFI_FEATURE_PNO,
521 WIFI_FEATURE_TDLS, WIFI_FEATURE_TDLS_OFFCHANNEL,
Ahmed ElArabawyb23485d2019-12-09 15:24:16 -0800522 WIFI_FEATURE_CONFIG_NDO, WIFI_FEATURE_MKEEP_ALIVE}) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700523 if (feature & legacy_feature_set) {
524 *hidl_caps |= convertLegacyFeatureToHidlStaIfaceCapability(feature);
525 }
526 }
527 // There is no flag for this one in the legacy feature set. Adding it to the
528 // set because all the current devices support it.
529 *hidl_caps |= HidlStaIfaceCaps::APF;
530 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800531}
532
533bool convertLegacyApfCapabilitiesToHidl(
534 const legacy_hal::PacketFilterCapabilities& legacy_caps,
535 StaApfPacketFilterCapabilities* hidl_caps) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700536 if (!hidl_caps) {
537 return false;
538 }
539 *hidl_caps = {};
540 hidl_caps->version = legacy_caps.version;
541 hidl_caps->maxLength = legacy_caps.max_len;
542 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800543}
544
Roshan Pius881d1f72016-12-05 15:37:00 -0800545uint8_t convertHidlGscanReportEventFlagToLegacy(
546 StaBackgroundScanBucketEventReportSchemeMask hidl_flag) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700547 using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
548 switch (hidl_flag) {
549 case HidlFlag::EACH_SCAN:
550 return REPORT_EVENTS_EACH_SCAN;
551 case HidlFlag::FULL_RESULTS:
552 return REPORT_EVENTS_FULL_RESULTS;
553 case HidlFlag::NO_BATCH:
554 return REPORT_EVENTS_NO_BATCH;
555 };
556 CHECK(false);
Roshan Pius881d1f72016-12-05 15:37:00 -0800557}
558
559StaScanDataFlagMask convertLegacyGscanDataFlagToHidl(uint8_t legacy_flag) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700560 switch (legacy_flag) {
561 case legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED:
562 return StaScanDataFlagMask::INTERRUPTED;
563 };
564 CHECK(false) << "Unknown legacy flag: " << legacy_flag;
565 // To silence the compiler warning about reaching the end of non-void
566 // function.
567 return {};
Roshan Pius881d1f72016-12-05 15:37:00 -0800568}
569
570bool convertLegacyGscanCapabilitiesToHidl(
Roshan Piusf72df2e2016-12-04 10:49:38 -0800571 const legacy_hal::wifi_gscan_capabilities& legacy_caps,
572 StaBackgroundScanCapabilities* hidl_caps) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700573 if (!hidl_caps) {
574 return false;
575 }
576 *hidl_caps = {};
577 hidl_caps->maxCacheSize = legacy_caps.max_scan_cache_size;
578 hidl_caps->maxBuckets = legacy_caps.max_scan_buckets;
579 hidl_caps->maxApCachePerScan = legacy_caps.max_ap_cache_per_scan;
580 hidl_caps->maxReportingThreshold = legacy_caps.max_scan_reporting_threshold;
581 return true;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800582}
583
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800584legacy_hal::wifi_band convertHidlWifiBandToLegacy(V1_0::WifiBand band) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700585 switch (band) {
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800586 case V1_0::WifiBand::BAND_UNSPECIFIED:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700587 return legacy_hal::WIFI_BAND_UNSPECIFIED;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800588 case V1_0::WifiBand::BAND_24GHZ:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700589 return legacy_hal::WIFI_BAND_BG;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800590 case V1_0::WifiBand::BAND_5GHZ:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700591 return legacy_hal::WIFI_BAND_A;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800592 case V1_0::WifiBand::BAND_5GHZ_DFS:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700593 return legacy_hal::WIFI_BAND_A_DFS;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800594 case V1_0::WifiBand::BAND_5GHZ_WITH_DFS:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700595 return legacy_hal::WIFI_BAND_A_WITH_DFS;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800596 case V1_0::WifiBand::BAND_24GHZ_5GHZ:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700597 return legacy_hal::WIFI_BAND_ABG;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800598 case V1_0::WifiBand::BAND_24GHZ_5GHZ_WITH_DFS:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700599 return legacy_hal::WIFI_BAND_ABG_WITH_DFS;
600 };
601 CHECK(false);
Roshan Pius881d1f72016-12-05 15:37:00 -0800602}
603
604bool convertHidlGscanParamsToLegacy(
Roshan Piuse65edb12016-11-22 13:02:01 -0800605 const StaBackgroundScanParameters& hidl_scan_params,
606 legacy_hal::wifi_scan_cmd_params* legacy_scan_params) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700607 if (!legacy_scan_params) {
608 return false;
Roshan Pius4cf40592017-03-07 11:17:08 -0800609 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700610 *legacy_scan_params = {};
611 legacy_scan_params->base_period = hidl_scan_params.basePeriodInMs;
612 legacy_scan_params->max_ap_per_scan = hidl_scan_params.maxApPerScan;
613 legacy_scan_params->report_threshold_percent =
614 hidl_scan_params.reportThresholdPercent;
615 legacy_scan_params->report_threshold_num_scans =
616 hidl_scan_params.reportThresholdNumScans;
617 if (hidl_scan_params.buckets.size() > MAX_BUCKETS) {
618 return false;
Roshan Piuse65edb12016-11-22 13:02:01 -0800619 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700620 legacy_scan_params->num_buckets = hidl_scan_params.buckets.size();
621 for (uint32_t bucket_idx = 0; bucket_idx < hidl_scan_params.buckets.size();
622 bucket_idx++) {
623 const StaBackgroundScanBucketParameters& hidl_bucket_spec =
624 hidl_scan_params.buckets[bucket_idx];
625 legacy_hal::wifi_scan_bucket_spec& legacy_bucket_spec =
626 legacy_scan_params->buckets[bucket_idx];
627 if (hidl_bucket_spec.bucketIdx >= MAX_BUCKETS) {
628 return false;
629 }
630 legacy_bucket_spec.bucket = hidl_bucket_spec.bucketIdx;
631 legacy_bucket_spec.band =
632 convertHidlWifiBandToLegacy(hidl_bucket_spec.band);
633 legacy_bucket_spec.period = hidl_bucket_spec.periodInMs;
634 legacy_bucket_spec.max_period =
635 hidl_bucket_spec.exponentialMaxPeriodInMs;
636 legacy_bucket_spec.base = hidl_bucket_spec.exponentialBase;
637 legacy_bucket_spec.step_count = hidl_bucket_spec.exponentialStepCount;
638 legacy_bucket_spec.report_events = 0;
639 using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
640 for (const auto flag : {HidlFlag::EACH_SCAN, HidlFlag::FULL_RESULTS,
641 HidlFlag::NO_BATCH}) {
642 if (hidl_bucket_spec.eventReportScheme &
643 static_cast<std::underlying_type<HidlFlag>::type>(flag)) {
644 legacy_bucket_spec.report_events |=
645 convertHidlGscanReportEventFlagToLegacy(flag);
646 }
647 }
648 if (hidl_bucket_spec.frequencies.size() > MAX_CHANNELS) {
649 return false;
650 }
651 legacy_bucket_spec.num_channels = hidl_bucket_spec.frequencies.size();
652 for (uint32_t freq_idx = 0;
653 freq_idx < hidl_bucket_spec.frequencies.size(); freq_idx++) {
654 legacy_bucket_spec.channels[freq_idx].channel =
655 hidl_bucket_spec.frequencies[freq_idx];
656 }
Roshan Piuse65edb12016-11-22 13:02:01 -0800657 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700658 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800659}
660
Roshan Pius3fae9c82016-12-02 14:49:41 -0800661bool convertLegacyIeToHidl(
662 const legacy_hal::wifi_information_element& legacy_ie,
663 WifiInformationElement* hidl_ie) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700664 if (!hidl_ie) {
665 return false;
666 }
667 *hidl_ie = {};
668 hidl_ie->id = legacy_ie.id;
669 hidl_ie->data =
670 std::vector<uint8_t>(legacy_ie.data, legacy_ie.data + legacy_ie.len);
671 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -0800672}
673
Roshan Piusabcf78f2017-10-06 16:30:38 -0700674bool convertLegacyIeBlobToHidl(const uint8_t* ie_blob, uint32_t ie_blob_len,
Roshan Piuse65edb12016-11-22 13:02:01 -0800675 std::vector<WifiInformationElement>* hidl_ies) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700676 if (!ie_blob || !hidl_ies) {
677 return false;
Roshan Piuse65edb12016-11-22 13:02:01 -0800678 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700679 *hidl_ies = {};
680 const uint8_t* ies_begin = ie_blob;
681 const uint8_t* ies_end = ie_blob + ie_blob_len;
682 const uint8_t* next_ie = ies_begin;
683 using wifi_ie = legacy_hal::wifi_information_element;
684 constexpr size_t kIeHeaderLen = sizeof(wifi_ie);
685 // Each IE should atleast have the header (i.e |id| & |len| fields).
686 while (next_ie + kIeHeaderLen <= ies_end) {
687 const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie));
688 uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len;
689 if (next_ie + curr_ie_len > ies_end) {
690 LOG(ERROR) << "Error parsing IE blob. Next IE: " << (void*)next_ie
691 << ", Curr IE len: " << curr_ie_len
692 << ", IEs End: " << (void*)ies_end;
693 break;
694 }
695 WifiInformationElement hidl_ie;
696 if (!convertLegacyIeToHidl(legacy_ie, &hidl_ie)) {
697 LOG(ERROR) << "Error converting IE. Id: " << legacy_ie.id
698 << ", len: " << legacy_ie.len;
699 break;
700 }
701 hidl_ies->push_back(std::move(hidl_ie));
702 next_ie += curr_ie_len;
Roshan Pius3fae9c82016-12-02 14:49:41 -0800703 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700704 // Check if the blob has been fully consumed.
705 if (next_ie != ies_end) {
706 LOG(ERROR) << "Failed to fully parse IE blob. Next IE: "
707 << (void*)next_ie << ", IEs End: " << (void*)ies_end;
708 }
709 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800710}
711
Roshan Pius881d1f72016-12-05 15:37:00 -0800712bool convertLegacyGscanResultToHidl(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700713 const legacy_hal::wifi_scan_result& legacy_scan_result, bool has_ie_data,
Roshan Piuse65edb12016-11-22 13:02:01 -0800714 StaScanResult* hidl_scan_result) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700715 if (!hidl_scan_result) {
716 return false;
Roshan Piuse65edb12016-11-22 13:02:01 -0800717 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700718 *hidl_scan_result = {};
719 hidl_scan_result->timeStampInUs = legacy_scan_result.ts;
720 hidl_scan_result->ssid = std::vector<uint8_t>(
721 legacy_scan_result.ssid,
722 legacy_scan_result.ssid + strnlen(legacy_scan_result.ssid,
723 sizeof(legacy_scan_result.ssid) - 1));
724 memcpy(hidl_scan_result->bssid.data(), legacy_scan_result.bssid,
725 hidl_scan_result->bssid.size());
726 hidl_scan_result->frequency = legacy_scan_result.channel;
727 hidl_scan_result->rssi = legacy_scan_result.rssi;
728 hidl_scan_result->beaconPeriodInMs = legacy_scan_result.beacon_period;
729 hidl_scan_result->capability = legacy_scan_result.capability;
730 if (has_ie_data) {
731 std::vector<WifiInformationElement> ies;
732 if (!convertLegacyIeBlobToHidl(
733 reinterpret_cast<const uint8_t*>(legacy_scan_result.ie_data),
734 legacy_scan_result.ie_length, &ies)) {
735 return false;
736 }
737 hidl_scan_result->informationElements = std::move(ies);
738 }
739 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800740}
741
Roshan Pius881d1f72016-12-05 15:37:00 -0800742bool convertLegacyCachedGscanResultsToHidl(
Roshan Piuse65edb12016-11-22 13:02:01 -0800743 const legacy_hal::wifi_cached_scan_results& legacy_cached_scan_result,
744 StaScanData* hidl_scan_data) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700745 if (!hidl_scan_data) {
746 return false;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800747 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700748 *hidl_scan_data = {};
749 hidl_scan_data->flags = 0;
750 for (const auto flag : {legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED}) {
751 if (legacy_cached_scan_result.flags & flag) {
752 hidl_scan_data->flags |=
753 static_cast<std::underlying_type<StaScanDataFlagMask>::type>(
754 convertLegacyGscanDataFlagToHidl(flag));
755 }
756 }
757 hidl_scan_data->bucketsScanned = legacy_cached_scan_result.buckets_scanned;
Roshan Piuse65edb12016-11-22 13:02:01 -0800758
Roshan Piusabcf78f2017-10-06 16:30:38 -0700759 CHECK(legacy_cached_scan_result.num_results >= 0 &&
760 legacy_cached_scan_result.num_results <= MAX_AP_CACHE_PER_SCAN);
761 std::vector<StaScanResult> hidl_scan_results;
762 for (int32_t result_idx = 0;
763 result_idx < legacy_cached_scan_result.num_results; result_idx++) {
764 StaScanResult hidl_scan_result;
765 if (!convertLegacyGscanResultToHidl(
766 legacy_cached_scan_result.results[result_idx], false,
767 &hidl_scan_result)) {
768 return false;
769 }
770 hidl_scan_results.push_back(hidl_scan_result);
Roshan Piuse65edb12016-11-22 13:02:01 -0800771 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700772 hidl_scan_data->results = std::move(hidl_scan_results);
773 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800774}
775
Roshan Pius881d1f72016-12-05 15:37:00 -0800776bool convertLegacyVectorOfCachedGscanResultsToHidl(
Roshan Piuse65edb12016-11-22 13:02:01 -0800777 const std::vector<legacy_hal::wifi_cached_scan_results>&
778 legacy_cached_scan_results,
779 std::vector<StaScanData>* hidl_scan_datas) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700780 if (!hidl_scan_datas) {
781 return false;
Roshan Piuse65edb12016-11-22 13:02:01 -0800782 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700783 *hidl_scan_datas = {};
784 for (const auto& legacy_cached_scan_result : legacy_cached_scan_results) {
785 StaScanData hidl_scan_data;
786 if (!convertLegacyCachedGscanResultsToHidl(legacy_cached_scan_result,
787 &hidl_scan_data)) {
788 return false;
789 }
790 hidl_scan_datas->push_back(hidl_scan_data);
791 }
792 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800793}
794
Roshan Pius32d0ca92016-12-02 11:21:19 -0800795WifiDebugTxPacketFate convertLegacyDebugTxPacketFateToHidl(
796 legacy_hal::wifi_tx_packet_fate fate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700797 switch (fate) {
798 case legacy_hal::TX_PKT_FATE_ACKED:
799 return WifiDebugTxPacketFate::ACKED;
800 case legacy_hal::TX_PKT_FATE_SENT:
801 return WifiDebugTxPacketFate::SENT;
802 case legacy_hal::TX_PKT_FATE_FW_QUEUED:
803 return WifiDebugTxPacketFate::FW_QUEUED;
804 case legacy_hal::TX_PKT_FATE_FW_DROP_INVALID:
805 return WifiDebugTxPacketFate::FW_DROP_INVALID;
806 case legacy_hal::TX_PKT_FATE_FW_DROP_NOBUFS:
807 return WifiDebugTxPacketFate::FW_DROP_NOBUFS;
808 case legacy_hal::TX_PKT_FATE_FW_DROP_OTHER:
809 return WifiDebugTxPacketFate::FW_DROP_OTHER;
810 case legacy_hal::TX_PKT_FATE_DRV_QUEUED:
811 return WifiDebugTxPacketFate::DRV_QUEUED;
812 case legacy_hal::TX_PKT_FATE_DRV_DROP_INVALID:
813 return WifiDebugTxPacketFate::DRV_DROP_INVALID;
814 case legacy_hal::TX_PKT_FATE_DRV_DROP_NOBUFS:
815 return WifiDebugTxPacketFate::DRV_DROP_NOBUFS;
816 case legacy_hal::TX_PKT_FATE_DRV_DROP_OTHER:
817 return WifiDebugTxPacketFate::DRV_DROP_OTHER;
818 };
819 CHECK(false) << "Unknown legacy fate type: " << fate;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800820}
821
822WifiDebugRxPacketFate convertLegacyDebugRxPacketFateToHidl(
823 legacy_hal::wifi_rx_packet_fate fate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700824 switch (fate) {
825 case legacy_hal::RX_PKT_FATE_SUCCESS:
826 return WifiDebugRxPacketFate::SUCCESS;
827 case legacy_hal::RX_PKT_FATE_FW_QUEUED:
828 return WifiDebugRxPacketFate::FW_QUEUED;
829 case legacy_hal::RX_PKT_FATE_FW_DROP_FILTER:
830 return WifiDebugRxPacketFate::FW_DROP_FILTER;
831 case legacy_hal::RX_PKT_FATE_FW_DROP_INVALID:
832 return WifiDebugRxPacketFate::FW_DROP_INVALID;
833 case legacy_hal::RX_PKT_FATE_FW_DROP_NOBUFS:
834 return WifiDebugRxPacketFate::FW_DROP_NOBUFS;
835 case legacy_hal::RX_PKT_FATE_FW_DROP_OTHER:
836 return WifiDebugRxPacketFate::FW_DROP_OTHER;
837 case legacy_hal::RX_PKT_FATE_DRV_QUEUED:
838 return WifiDebugRxPacketFate::DRV_QUEUED;
839 case legacy_hal::RX_PKT_FATE_DRV_DROP_FILTER:
840 return WifiDebugRxPacketFate::DRV_DROP_FILTER;
841 case legacy_hal::RX_PKT_FATE_DRV_DROP_INVALID:
842 return WifiDebugRxPacketFate::DRV_DROP_INVALID;
843 case legacy_hal::RX_PKT_FATE_DRV_DROP_NOBUFS:
844 return WifiDebugRxPacketFate::DRV_DROP_NOBUFS;
845 case legacy_hal::RX_PKT_FATE_DRV_DROP_OTHER:
846 return WifiDebugRxPacketFate::DRV_DROP_OTHER;
847 };
848 CHECK(false) << "Unknown legacy fate type: " << fate;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800849}
850
851WifiDebugPacketFateFrameType convertLegacyDebugPacketFateFrameTypeToHidl(
852 legacy_hal::frame_type type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700853 switch (type) {
854 case legacy_hal::FRAME_TYPE_UNKNOWN:
855 return WifiDebugPacketFateFrameType::UNKNOWN;
856 case legacy_hal::FRAME_TYPE_ETHERNET_II:
857 return WifiDebugPacketFateFrameType::ETHERNET_II;
858 case legacy_hal::FRAME_TYPE_80211_MGMT:
859 return WifiDebugPacketFateFrameType::MGMT_80211;
860 };
861 CHECK(false) << "Unknown legacy frame type: " << type;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800862}
863
864bool convertLegacyDebugPacketFateFrameToHidl(
865 const legacy_hal::frame_info& legacy_frame,
866 WifiDebugPacketFateFrameInfo* hidl_frame) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700867 if (!hidl_frame) {
868 return false;
869 }
870 *hidl_frame = {};
871 hidl_frame->frameType =
872 convertLegacyDebugPacketFateFrameTypeToHidl(legacy_frame.payload_type);
873 hidl_frame->frameLen = legacy_frame.frame_len;
874 hidl_frame->driverTimestampUsec = legacy_frame.driver_timestamp_usec;
875 hidl_frame->firmwareTimestampUsec = legacy_frame.firmware_timestamp_usec;
876 const uint8_t* frame_begin = reinterpret_cast<const uint8_t*>(
877 legacy_frame.frame_content.ethernet_ii_bytes);
878 hidl_frame->frameContent =
879 std::vector<uint8_t>(frame_begin, frame_begin + legacy_frame.frame_len);
880 return true;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800881}
882
883bool convertLegacyDebugTxPacketFateToHidl(
884 const legacy_hal::wifi_tx_report& legacy_fate,
885 WifiDebugTxPacketFateReport* hidl_fate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700886 if (!hidl_fate) {
887 return false;
888 }
889 *hidl_fate = {};
890 hidl_fate->fate = convertLegacyDebugTxPacketFateToHidl(legacy_fate.fate);
891 return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
892 &hidl_fate->frameInfo);
Roshan Pius32d0ca92016-12-02 11:21:19 -0800893}
894
Roshan Piusf72df2e2016-12-04 10:49:38 -0800895bool convertLegacyVectorOfDebugTxPacketFateToHidl(
896 const std::vector<legacy_hal::wifi_tx_report>& legacy_fates,
897 std::vector<WifiDebugTxPacketFateReport>* hidl_fates) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700898 if (!hidl_fates) {
899 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800900 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700901 *hidl_fates = {};
902 for (const auto& legacy_fate : legacy_fates) {
903 WifiDebugTxPacketFateReport hidl_fate;
904 if (!convertLegacyDebugTxPacketFateToHidl(legacy_fate, &hidl_fate)) {
905 return false;
906 }
907 hidl_fates->push_back(hidl_fate);
908 }
909 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800910}
911
Roshan Pius32d0ca92016-12-02 11:21:19 -0800912bool convertLegacyDebugRxPacketFateToHidl(
913 const legacy_hal::wifi_rx_report& legacy_fate,
914 WifiDebugRxPacketFateReport* hidl_fate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700915 if (!hidl_fate) {
916 return false;
917 }
918 *hidl_fate = {};
919 hidl_fate->fate = convertLegacyDebugRxPacketFateToHidl(legacy_fate.fate);
920 return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
921 &hidl_fate->frameInfo);
Roshan Pius32d0ca92016-12-02 11:21:19 -0800922}
923
Roshan Piusf72df2e2016-12-04 10:49:38 -0800924bool convertLegacyVectorOfDebugRxPacketFateToHidl(
925 const std::vector<legacy_hal::wifi_rx_report>& legacy_fates,
926 std::vector<WifiDebugRxPacketFateReport>* hidl_fates) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700927 if (!hidl_fates) {
928 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800929 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700930 *hidl_fates = {};
931 for (const auto& legacy_fate : legacy_fates) {
932 WifiDebugRxPacketFateReport hidl_fate;
933 if (!convertLegacyDebugRxPacketFateToHidl(legacy_fate, &hidl_fate)) {
934 return false;
935 }
936 hidl_fates->push_back(hidl_fate);
937 }
938 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800939}
940
Sunil Ravib0343e72018-11-13 15:52:00 -0800941bool convertLegacyLinkLayerRadioStatsToHidl(
942 const legacy_hal::LinkLayerRadioStats& legacy_radio_stat,
943 V1_3::StaLinkLayerRadioStats* hidl_radio_stat) {
944 if (!hidl_radio_stat) {
945 return false;
946 }
947 *hidl_radio_stat = {};
948
949 hidl_radio_stat->V1_0.onTimeInMs = legacy_radio_stat.stats.on_time;
950 hidl_radio_stat->V1_0.txTimeInMs = legacy_radio_stat.stats.tx_time;
951 hidl_radio_stat->V1_0.rxTimeInMs = legacy_radio_stat.stats.rx_time;
952 hidl_radio_stat->V1_0.onTimeInMsForScan =
953 legacy_radio_stat.stats.on_time_scan;
954 hidl_radio_stat->V1_0.txTimeInMsPerLevel =
955 legacy_radio_stat.tx_time_per_levels;
956 hidl_radio_stat->onTimeInMsForNanScan = legacy_radio_stat.stats.on_time_nbd;
957 hidl_radio_stat->onTimeInMsForBgScan =
958 legacy_radio_stat.stats.on_time_gscan;
959 hidl_radio_stat->onTimeInMsForRoamScan =
960 legacy_radio_stat.stats.on_time_roam_scan;
961 hidl_radio_stat->onTimeInMsForPnoScan =
962 legacy_radio_stat.stats.on_time_pno_scan;
963 hidl_radio_stat->onTimeInMsForHs20Scan =
964 legacy_radio_stat.stats.on_time_hs20;
965
966 std::vector<V1_3::WifiChannelStats> hidl_channel_stats;
967
968 for (const auto& channel_stat : legacy_radio_stat.channel_stats) {
969 V1_3::WifiChannelStats hidl_channel_stat;
970 hidl_channel_stat.onTimeInMs = channel_stat.on_time;
971 hidl_channel_stat.ccaBusyTimeInMs = channel_stat.cca_busy_time;
972 /*
973 * TODO once b/119142899 is fixed,
974 * replace below code with convertLegacyWifiChannelInfoToHidl()
975 */
976 hidl_channel_stat.channel.width = WifiChannelWidthInMhz::WIDTH_20;
977 hidl_channel_stat.channel.centerFreq = channel_stat.channel.center_freq;
978 hidl_channel_stat.channel.centerFreq0 =
979 channel_stat.channel.center_freq0;
980 hidl_channel_stat.channel.centerFreq1 =
981 channel_stat.channel.center_freq1;
982 hidl_channel_stats.push_back(hidl_channel_stat);
983 }
984
985 hidl_radio_stat->channelStats = hidl_channel_stats;
986
987 return true;
988}
989
Roshan Piuse65edb12016-11-22 13:02:01 -0800990bool convertLegacyLinkLayerStatsToHidl(
991 const legacy_hal::LinkLayerStats& legacy_stats,
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800992 StaLinkLayerStats* hidl_stats) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700993 if (!hidl_stats) {
994 return false;
995 }
996 *hidl_stats = {};
997 // iface legacy_stats conversion.
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800998 hidl_stats->iface.V1_0.beaconRx = legacy_stats.iface.beacon_rx;
999 hidl_stats->iface.V1_0.avgRssiMgmt = legacy_stats.iface.rssi_mgmt;
1000 hidl_stats->iface.V1_0.wmeBePktStats.rxMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001001 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001002 hidl_stats->iface.V1_0.wmeBePktStats.txMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001003 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001004 hidl_stats->iface.V1_0.wmeBePktStats.lostMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001005 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001006 hidl_stats->iface.V1_0.wmeBePktStats.retries =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001007 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries;
Mingguang Xua6d0b842021-02-12 14:53:37 -08001008 hidl_stats->iface.wmeBeContentionTimeStats.contentionTimeMinInUsec =
1009 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_min;
1010 hidl_stats->iface.wmeBeContentionTimeStats.contentionTimeMaxInUsec =
1011 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_max;
1012 hidl_stats->iface.wmeBeContentionTimeStats.contentionTimeAvgInUsec =
1013 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_avg;
1014 hidl_stats->iface.wmeBeContentionTimeStats.contentionNumSamples =
1015 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001016 hidl_stats->iface.V1_0.wmeBkPktStats.rxMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001017 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001018 hidl_stats->iface.V1_0.wmeBkPktStats.txMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001019 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001020 hidl_stats->iface.V1_0.wmeBkPktStats.lostMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001021 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001022 hidl_stats->iface.V1_0.wmeBkPktStats.retries =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001023 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries;
Mingguang Xua6d0b842021-02-12 14:53:37 -08001024 hidl_stats->iface.wmeBkContentionTimeStats.contentionTimeMinInUsec =
1025 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_min;
1026 hidl_stats->iface.wmeBkContentionTimeStats.contentionTimeMaxInUsec =
1027 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_max;
1028 hidl_stats->iface.wmeBkContentionTimeStats.contentionTimeAvgInUsec =
1029 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_avg;
1030 hidl_stats->iface.wmeBkContentionTimeStats.contentionNumSamples =
1031 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001032 hidl_stats->iface.V1_0.wmeViPktStats.rxMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001033 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001034 hidl_stats->iface.V1_0.wmeViPktStats.txMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001035 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001036 hidl_stats->iface.V1_0.wmeViPktStats.lostMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001037 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001038 hidl_stats->iface.V1_0.wmeViPktStats.retries =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001039 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries;
Mingguang Xua6d0b842021-02-12 14:53:37 -08001040 hidl_stats->iface.wmeViContentionTimeStats.contentionTimeMinInUsec =
1041 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_min;
1042 hidl_stats->iface.wmeViContentionTimeStats.contentionTimeMaxInUsec =
1043 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_max;
1044 hidl_stats->iface.wmeViContentionTimeStats.contentionTimeAvgInUsec =
1045 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_avg;
1046 hidl_stats->iface.wmeViContentionTimeStats.contentionNumSamples =
1047 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001048 hidl_stats->iface.V1_0.wmeVoPktStats.rxMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001049 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001050 hidl_stats->iface.V1_0.wmeVoPktStats.txMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001051 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001052 hidl_stats->iface.V1_0.wmeVoPktStats.lostMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001053 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001054 hidl_stats->iface.V1_0.wmeVoPktStats.retries =
Roshan Piusabcf78f2017-10-06 16:30:38 -07001055 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries;
Mingguang Xua6d0b842021-02-12 14:53:37 -08001056 hidl_stats->iface.wmeVoContentionTimeStats.contentionTimeMinInUsec =
1057 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_min;
1058 hidl_stats->iface.wmeVoContentionTimeStats.contentionTimeMaxInUsec =
1059 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_max;
1060 hidl_stats->iface.wmeVoContentionTimeStats.contentionTimeAvgInUsec =
1061 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_avg;
1062 hidl_stats->iface.wmeVoContentionTimeStats.contentionNumSamples =
1063 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08001064 hidl_stats->iface.timeSliceDutyCycleInPercent =
1065 legacy_stats.iface.info.time_slicing_duty_cycle_percent;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001066 // radio legacy_stats conversion.
xshue9873252018-08-07 11:04:34 -07001067 std::vector<V1_3::StaLinkLayerRadioStats> hidl_radios_stats;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001068 for (const auto& legacy_radio_stats : legacy_stats.radios) {
xshue9873252018-08-07 11:04:34 -07001069 V1_3::StaLinkLayerRadioStats hidl_radio_stats;
Sunil Ravib0343e72018-11-13 15:52:00 -08001070 if (!convertLegacyLinkLayerRadioStatsToHidl(legacy_radio_stats,
1071 &hidl_radio_stats)) {
1072 return false;
1073 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001074 hidl_radios_stats.push_back(hidl_radio_stats);
1075 }
1076 hidl_stats->radios = hidl_radios_stats;
1077 // Timestamp in the HAL wrapper here since it's not provided in the legacy
1078 // HAL API.
1079 hidl_stats->timeStampInMs = uptimeMillis();
1080 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -08001081}
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001082
Roshan Pius26801cb2016-12-13 14:25:45 -08001083bool convertLegacyRoamingCapabilitiesToHidl(
1084 const legacy_hal::wifi_roaming_capabilities& legacy_caps,
1085 StaRoamingCapabilities* hidl_caps) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001086 if (!hidl_caps) {
1087 return false;
1088 }
1089 *hidl_caps = {};
1090 hidl_caps->maxBlacklistSize = legacy_caps.max_blacklist_size;
1091 hidl_caps->maxWhitelistSize = legacy_caps.max_whitelist_size;
1092 return true;
Roshan Pius26801cb2016-12-13 14:25:45 -08001093}
1094
1095bool convertHidlRoamingConfigToLegacy(
1096 const StaRoamingConfig& hidl_config,
1097 legacy_hal::wifi_roaming_config* legacy_config) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001098 if (!legacy_config) {
1099 return false;
1100 }
1101 *legacy_config = {};
1102 if (hidl_config.bssidBlacklist.size() > MAX_BLACKLIST_BSSID ||
1103 hidl_config.ssidWhitelist.size() > MAX_WHITELIST_SSID) {
1104 return false;
1105 }
1106 legacy_config->num_blacklist_bssid = hidl_config.bssidBlacklist.size();
1107 uint32_t i = 0;
1108 for (const auto& bssid : hidl_config.bssidBlacklist) {
1109 CHECK(bssid.size() == sizeof(legacy_hal::mac_addr));
1110 memcpy(legacy_config->blacklist_bssid[i++], bssid.data(), bssid.size());
1111 }
1112 legacy_config->num_whitelist_ssid = hidl_config.ssidWhitelist.size();
1113 i = 0;
1114 for (const auto& ssid : hidl_config.ssidWhitelist) {
1115 CHECK(ssid.size() <= sizeof(legacy_hal::ssid_t::ssid_str));
1116 legacy_config->whitelist_ssid[i].length = ssid.size();
1117 memcpy(legacy_config->whitelist_ssid[i].ssid_str, ssid.data(),
1118 ssid.size());
1119 i++;
1120 }
1121 return true;
Roshan Pius26801cb2016-12-13 14:25:45 -08001122}
1123
1124legacy_hal::fw_roaming_state_t convertHidlRoamingStateToLegacy(
1125 StaRoamingState state) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001126 switch (state) {
1127 case StaRoamingState::ENABLED:
1128 return legacy_hal::ROAMING_ENABLE;
1129 case StaRoamingState::DISABLED:
1130 return legacy_hal::ROAMING_DISABLE;
1131 };
1132 CHECK(false);
Roshan Pius26801cb2016-12-13 14:25:45 -08001133}
1134
Etan Cohen67d378d2017-04-03 16:10:54 -07001135legacy_hal::NanMatchAlg convertHidlNanMatchAlgToLegacy(NanMatchAlg type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001136 switch (type) {
1137 case NanMatchAlg::MATCH_ONCE:
1138 return legacy_hal::NAN_MATCH_ALG_MATCH_ONCE;
1139 case NanMatchAlg::MATCH_CONTINUOUS:
1140 return legacy_hal::NAN_MATCH_ALG_MATCH_CONTINUOUS;
1141 case NanMatchAlg::MATCH_NEVER:
1142 return legacy_hal::NAN_MATCH_ALG_MATCH_NEVER;
1143 }
1144 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001145}
1146
Roshan Piusabcf78f2017-10-06 16:30:38 -07001147legacy_hal::NanPublishType convertHidlNanPublishTypeToLegacy(
1148 NanPublishType type) {
1149 switch (type) {
1150 case NanPublishType::UNSOLICITED:
1151 return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED;
1152 case NanPublishType::SOLICITED:
1153 return legacy_hal::NAN_PUBLISH_TYPE_SOLICITED;
1154 case NanPublishType::UNSOLICITED_SOLICITED:
1155 return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
1156 }
1157 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001158}
1159
1160legacy_hal::NanTxType convertHidlNanTxTypeToLegacy(NanTxType type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001161 switch (type) {
1162 case NanTxType::BROADCAST:
1163 return legacy_hal::NAN_TX_TYPE_BROADCAST;
1164 case NanTxType::UNICAST:
1165 return legacy_hal::NAN_TX_TYPE_UNICAST;
1166 }
1167 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001168}
1169
Roshan Piusabcf78f2017-10-06 16:30:38 -07001170legacy_hal::NanSubscribeType convertHidlNanSubscribeTypeToLegacy(
1171 NanSubscribeType type) {
1172 switch (type) {
1173 case NanSubscribeType::PASSIVE:
1174 return legacy_hal::NAN_SUBSCRIBE_TYPE_PASSIVE;
1175 case NanSubscribeType::ACTIVE:
1176 return legacy_hal::NAN_SUBSCRIBE_TYPE_ACTIVE;
1177 }
1178 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001179}
1180
1181legacy_hal::NanSRFType convertHidlNanSrfTypeToLegacy(NanSrfType type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001182 switch (type) {
1183 case NanSrfType::BLOOM_FILTER:
1184 return legacy_hal::NAN_SRF_ATTR_BLOOM_FILTER;
1185 case NanSrfType::PARTIAL_MAC_ADDR:
1186 return legacy_hal::NAN_SRF_ATTR_PARTIAL_MAC_ADDR;
1187 }
1188 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001189}
1190
1191legacy_hal::NanDataPathChannelCfg convertHidlNanDataPathChannelCfgToLegacy(
1192 NanDataPathChannelCfg type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001193 switch (type) {
1194 case NanDataPathChannelCfg::CHANNEL_NOT_REQUESTED:
1195 return legacy_hal::NAN_DP_CHANNEL_NOT_REQUESTED;
1196 case NanDataPathChannelCfg::REQUEST_CHANNEL_SETUP:
1197 return legacy_hal::NAN_DP_REQUEST_CHANNEL_SETUP;
1198 case NanDataPathChannelCfg::FORCE_CHANNEL_SETUP:
1199 return legacy_hal::NAN_DP_FORCE_CHANNEL_SETUP;
1200 }
1201 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001202}
1203
Roshan Piusabcf78f2017-10-06 16:30:38 -07001204NanStatusType convertLegacyNanStatusTypeToHidl(legacy_hal::NanStatusType type) {
1205 switch (type) {
1206 case legacy_hal::NAN_STATUS_SUCCESS:
1207 return NanStatusType::SUCCESS;
1208 case legacy_hal::NAN_STATUS_INTERNAL_FAILURE:
1209 return NanStatusType::INTERNAL_FAILURE;
1210 case legacy_hal::NAN_STATUS_PROTOCOL_FAILURE:
1211 return NanStatusType::PROTOCOL_FAILURE;
1212 case legacy_hal::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID:
1213 return NanStatusType::INVALID_SESSION_ID;
1214 case legacy_hal::NAN_STATUS_NO_RESOURCE_AVAILABLE:
1215 return NanStatusType::NO_RESOURCES_AVAILABLE;
1216 case legacy_hal::NAN_STATUS_INVALID_PARAM:
1217 return NanStatusType::INVALID_ARGS;
1218 case legacy_hal::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID:
1219 return NanStatusType::INVALID_PEER_ID;
1220 case legacy_hal::NAN_STATUS_INVALID_NDP_ID:
1221 return NanStatusType::INVALID_NDP_ID;
1222 case legacy_hal::NAN_STATUS_NAN_NOT_ALLOWED:
1223 return NanStatusType::NAN_NOT_ALLOWED;
1224 case legacy_hal::NAN_STATUS_NO_OTA_ACK:
1225 return NanStatusType::NO_OTA_ACK;
1226 case legacy_hal::NAN_STATUS_ALREADY_ENABLED:
1227 return NanStatusType::ALREADY_ENABLED;
1228 case legacy_hal::NAN_STATUS_FOLLOWUP_QUEUE_FULL:
1229 return NanStatusType::FOLLOWUP_TX_QUEUE_FULL;
1230 case legacy_hal::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED:
1231 return NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED;
1232 }
1233 CHECK(false);
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001234}
1235
Roshan Piusabcf78f2017-10-06 16:30:38 -07001236void convertToWifiNanStatus(legacy_hal::NanStatusType type, const char* str,
1237 size_t max_len, WifiNanStatus* wifiNanStatus) {
1238 wifiNanStatus->status = convertLegacyNanStatusTypeToHidl(type);
1239 wifiNanStatus->description = safeConvertChar(str, max_len);
Etan Cohenbbc0f092017-04-26 16:52:34 -07001240}
1241
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001242bool convertHidlNanEnableRequestToLegacy(
Jimmy Chend460df32019-11-29 17:31:22 +02001243 const V1_4::NanEnableRequest& hidl_request,
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001244 legacy_hal::NanEnableRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001245 if (!legacy_request) {
1246 LOG(ERROR)
1247 << "convertHidlNanEnableRequestToLegacy: null legacy_request";
1248 return false;
1249 }
1250 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001251
Roshan Piusabcf78f2017-10-06 16:30:38 -07001252 legacy_request->config_2dot4g_support = 1;
1253 legacy_request->support_2dot4g_val =
1254 hidl_request.operateInBand[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1255 legacy_request->config_support_5g = 1;
1256 legacy_request->support_5g_val =
1257 hidl_request.operateInBand[(size_t)NanBandIndex::NAN_BAND_5GHZ];
1258 legacy_request->config_hop_count_limit = 1;
1259 legacy_request->hop_count_limit_val = hidl_request.hopCountMax;
1260 legacy_request->master_pref = hidl_request.configParams.masterPref;
1261 legacy_request->discovery_indication_cfg = 0;
1262 legacy_request->discovery_indication_cfg |=
1263 hidl_request.configParams.disableDiscoveryAddressChangeIndication ? 0x1
1264 : 0x0;
1265 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001266 hidl_request.configParams.disableStartedClusterIndication ? 0x2 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001267 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001268 hidl_request.configParams.disableJoinedClusterIndication ? 0x4 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001269 legacy_request->config_sid_beacon = 1;
1270 if (hidl_request.configParams.numberOfPublishServiceIdsInBeacon > 127) {
1271 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
1272 "numberOfPublishServiceIdsInBeacon > 127";
1273 return false;
1274 }
1275 legacy_request->sid_beacon_val =
1276 (hidl_request.configParams.includePublishServiceIdsInBeacon ? 0x1
1277 : 0x0) |
1278 (hidl_request.configParams.numberOfPublishServiceIdsInBeacon << 1);
1279 legacy_request->config_subscribe_sid_beacon = 1;
1280 if (hidl_request.configParams.numberOfSubscribeServiceIdsInBeacon > 127) {
1281 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
1282 "numberOfSubscribeServiceIdsInBeacon > 127";
1283 return false;
1284 }
1285 legacy_request->subscribe_sid_beacon_val =
1286 (hidl_request.configParams.includeSubscribeServiceIdsInBeacon ? 0x1
1287 : 0x0) |
1288 (hidl_request.configParams.numberOfSubscribeServiceIdsInBeacon << 1);
1289 legacy_request->config_rssi_window_size = 1;
1290 legacy_request->rssi_window_size_val =
1291 hidl_request.configParams.rssiWindowSize;
1292 legacy_request->config_disc_mac_addr_randomization = 1;
1293 legacy_request->disc_mac_addr_rand_interval_sec =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001294 hidl_request.configParams.macAddressRandomizationIntervalSec;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001295 legacy_request->config_2dot4g_rssi_close = 1;
Nate(Qiang) Jiang18b38eb2019-12-11 12:48:13 -08001296 if (hidl_request.configParams.bandSpecificConfig.size() != 3) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001297 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
Nate(Qiang) Jiang18b38eb2019-12-11 12:48:13 -08001298 "bandSpecificConfig.size() != 3";
Roshan Piusabcf78f2017-10-06 16:30:38 -07001299 return false;
1300 }
1301 legacy_request->rssi_close_2dot4g_val =
1302 hidl_request.configParams
1303 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1304 .rssiClose;
1305 legacy_request->config_2dot4g_rssi_middle = 1;
1306 legacy_request->rssi_middle_2dot4g_val =
1307 hidl_request.configParams
1308 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1309 .rssiMiddle;
1310 legacy_request->config_2dot4g_rssi_proximity = 1;
1311 legacy_request->rssi_proximity_2dot4g_val =
1312 hidl_request.configParams
1313 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1314 .rssiCloseProximity;
1315 legacy_request->config_scan_params = 1;
1316 legacy_request->scan_params_val
1317 .dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
1318 hidl_request.configParams
1319 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1320 .dwellTimeMs;
1321 legacy_request->scan_params_val
1322 .scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
1323 hidl_request.configParams
1324 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1325 .scanPeriodSec;
1326 legacy_request->config_dw.config_2dot4g_dw_band =
1327 hidl_request.configParams
1328 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1329 .validDiscoveryWindowIntervalVal;
1330 legacy_request->config_dw.dw_2dot4g_interval_val =
1331 hidl_request.configParams
1332 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1333 .discoveryWindowIntervalVal;
1334 legacy_request->config_5g_rssi_close = 1;
1335 legacy_request->rssi_close_5g_val =
1336 hidl_request.configParams
1337 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1338 .rssiClose;
1339 legacy_request->config_5g_rssi_middle = 1;
1340 legacy_request->rssi_middle_5g_val =
1341 hidl_request.configParams
1342 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1343 .rssiMiddle;
1344 legacy_request->config_5g_rssi_close_proximity = 1;
1345 legacy_request->rssi_close_proximity_5g_val =
1346 hidl_request.configParams
1347 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1348 .rssiCloseProximity;
1349 legacy_request->scan_params_val
1350 .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1351 hidl_request.configParams
1352 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1353 .dwellTimeMs;
1354 legacy_request->scan_params_val
1355 .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1356 hidl_request.configParams
1357 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1358 .scanPeriodSec;
1359 legacy_request->scan_params_val
1360 .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1361 hidl_request.configParams
1362 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1363 .dwellTimeMs;
1364 legacy_request->scan_params_val
1365 .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1366 hidl_request.configParams
1367 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1368 .scanPeriodSec;
1369 legacy_request->config_dw.config_5g_dw_band =
1370 hidl_request.configParams
1371 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1372 .validDiscoveryWindowIntervalVal;
1373 legacy_request->config_dw.dw_5g_interval_val =
1374 hidl_request.configParams
1375 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1376 .discoveryWindowIntervalVal;
1377 if (hidl_request.debugConfigs.validClusterIdVals) {
1378 legacy_request->cluster_low =
1379 hidl_request.debugConfigs.clusterIdBottomRangeVal;
1380 legacy_request->cluster_high =
1381 hidl_request.debugConfigs.clusterIdTopRangeVal;
1382 } else { // need 'else' since not configurable in legacy HAL
1383 legacy_request->cluster_low = 0x0000;
1384 legacy_request->cluster_high = 0xFFFF;
1385 }
1386 legacy_request->config_intf_addr =
1387 hidl_request.debugConfigs.validIntfAddrVal;
1388 memcpy(legacy_request->intf_addr_val,
1389 hidl_request.debugConfigs.intfAddrVal.data(), 6);
1390 legacy_request->config_oui = hidl_request.debugConfigs.validOuiVal;
1391 legacy_request->oui_val = hidl_request.debugConfigs.ouiVal;
1392 legacy_request->config_random_factor_force =
1393 hidl_request.debugConfigs.validRandomFactorForceVal;
1394 legacy_request->random_factor_force_val =
1395 hidl_request.debugConfigs.randomFactorForceVal;
1396 legacy_request->config_hop_count_force =
1397 hidl_request.debugConfigs.validHopCountForceVal;
1398 legacy_request->hop_count_force_val =
1399 hidl_request.debugConfigs.hopCountForceVal;
1400 legacy_request->config_24g_channel =
1401 hidl_request.debugConfigs.validDiscoveryChannelVal;
1402 legacy_request->channel_24g_val =
1403 hidl_request.debugConfigs
1404 .discoveryChannelMhzVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1405 legacy_request->config_5g_channel =
1406 hidl_request.debugConfigs.validDiscoveryChannelVal;
1407 legacy_request->channel_5g_val =
1408 hidl_request.debugConfigs
1409 .discoveryChannelMhzVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
1410 legacy_request->config_2dot4g_beacons =
1411 hidl_request.debugConfigs.validUseBeaconsInBandVal;
1412 legacy_request->beacon_2dot4g_val =
1413 hidl_request.debugConfigs
1414 .useBeaconsInBandVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1415 legacy_request->config_5g_beacons =
1416 hidl_request.debugConfigs.validUseBeaconsInBandVal;
1417 legacy_request->beacon_5g_val =
1418 hidl_request.debugConfigs
1419 .useBeaconsInBandVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
1420 legacy_request->config_2dot4g_sdf =
1421 hidl_request.debugConfigs.validUseSdfInBandVal;
1422 legacy_request->sdf_2dot4g_val =
1423 hidl_request.debugConfigs
1424 .useSdfInBandVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1425 legacy_request->config_5g_sdf =
1426 hidl_request.debugConfigs.validUseSdfInBandVal;
1427 legacy_request->sdf_5g_val =
1428 hidl_request.debugConfigs
1429 .useSdfInBandVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001430
Ahmed ElArabawy83baffd2019-11-15 19:20:41 -08001431 /* TODO: b/145609058
1432 * Missing updates needed to legacy_hal::NanEnableRequest and conversion to
1433 * it for 6GHz band */
1434
Roshan Piusabcf78f2017-10-06 16:30:38 -07001435 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001436}
1437
Ahmed ElArabawy83baffd2019-11-15 19:20:41 -08001438bool convertHidlNanEnableRequest_1_4ToLegacy(
Jimmy Chend460df32019-11-29 17:31:22 +02001439 const V1_4::NanEnableRequest& hidl_request1,
Nate Jiang3ec67812020-08-24 11:04:31 -07001440 const NanConfigRequestSupplemental& hidl_request2,
Etan Cohen9e7a4052017-12-21 13:45:26 -08001441 legacy_hal::NanEnableRequest* legacy_request) {
1442 if (!legacy_request) {
1443 LOG(ERROR)
Ahmed ElArabawy83baffd2019-11-15 19:20:41 -08001444 << "convertHidlNanEnableRequest_1_4ToLegacy: null legacy_request";
Etan Cohen9e7a4052017-12-21 13:45:26 -08001445 return false;
1446 }
1447
1448 *legacy_request = {};
1449 if (!convertHidlNanEnableRequestToLegacy(hidl_request1, legacy_request)) {
1450 return false;
1451 }
1452
1453 legacy_request->config_discovery_beacon_int = 1;
1454 legacy_request->discovery_beacon_interval =
Nate Jiang3ec67812020-08-24 11:04:31 -07001455 hidl_request2.V1_2.discoveryBeaconIntervalMs;
Etan Cohen9e7a4052017-12-21 13:45:26 -08001456 legacy_request->config_nss = 1;
Nate Jiang3ec67812020-08-24 11:04:31 -07001457 legacy_request->nss = hidl_request2.V1_2.numberOfSpatialStreamsInDiscovery;
Etan Cohen9e7a4052017-12-21 13:45:26 -08001458 legacy_request->config_dw_early_termination = 1;
1459 legacy_request->enable_dw_termination =
Nate Jiang3ec67812020-08-24 11:04:31 -07001460 hidl_request2.V1_2.enableDiscoveryWindowEarlyTermination;
Etan Cohen4f5bc6c2017-12-28 13:08:08 -08001461 legacy_request->config_enable_ranging = 1;
Nate Jiang3ec67812020-08-24 11:04:31 -07001462 legacy_request->enable_ranging = hidl_request2.V1_2.enableRanging;
1463
1464 return true;
1465}
1466
1467bool convertHidlNanEnableRequest_1_5ToLegacy(
1468 const V1_4::NanEnableRequest& hidl_request1,
1469 const NanConfigRequestSupplemental& hidl_request2,
1470 legacy_hal::NanEnableRequest* legacy_request) {
1471 if (!legacy_request) {
1472 LOG(ERROR)
1473 << "convertHidlNanEnableRequest_1_5ToLegacy: null legacy_request";
1474 return false;
1475 }
1476
1477 *legacy_request = {};
1478 if (!convertHidlNanEnableRequest_1_4ToLegacy(hidl_request1, hidl_request2,
1479 legacy_request)) {
1480 return false;
1481 }
1482
1483 legacy_request->config_enable_instant_mode = 1;
1484 legacy_request->enable_instant_mode =
1485 hidl_request2.enableInstantCommunicationMode;
1486
1487 return true;
1488}
1489
1490bool convertHidlNanConfigRequest_1_5ToLegacy(
1491 const V1_4::NanConfigRequest& hidl_request1,
1492 const NanConfigRequestSupplemental& hidl_request2,
1493 legacy_hal::NanConfigRequest* legacy_request) {
1494 if (!legacy_request) {
1495 LOG(ERROR)
1496 << "convertHidlNanConfigRequest_1_5ToLegacy: null legacy_request";
1497 return false;
1498 }
1499
1500 *legacy_request = {};
1501 if (!convertHidlNanConfigRequest_1_4ToLegacy(hidl_request1, hidl_request2,
1502 legacy_request)) {
1503 return false;
1504 }
1505
1506 legacy_request->config_enable_instant_mode = 1;
1507 legacy_request->enable_instant_mode =
1508 hidl_request2.enableInstantCommunicationMode;
Etan Cohen9e7a4052017-12-21 13:45:26 -08001509
1510 return true;
1511}
1512
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001513bool convertHidlNanPublishRequestToLegacy(
1514 const NanPublishRequest& hidl_request,
1515 legacy_hal::NanPublishRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001516 if (!legacy_request) {
1517 LOG(ERROR)
1518 << "convertHidlNanPublishRequestToLegacy: null legacy_request";
1519 return false;
1520 }
1521 *legacy_request = {};
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001522
Roshan Piusabcf78f2017-10-06 16:30:38 -07001523 legacy_request->publish_id = hidl_request.baseConfigs.sessionId;
1524 legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
1525 legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
1526 legacy_request->publish_count = hidl_request.baseConfigs.discoveryCount;
1527 legacy_request->service_name_len =
1528 hidl_request.baseConfigs.serviceName.size();
1529 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1530 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: service_name_len "
1531 "too large";
1532 return false;
1533 }
1534 memcpy(legacy_request->service_name,
1535 hidl_request.baseConfigs.serviceName.data(),
1536 legacy_request->service_name_len);
1537 legacy_request->publish_match_indicator = convertHidlNanMatchAlgToLegacy(
1538 hidl_request.baseConfigs.discoveryMatchIndicator);
1539 legacy_request->service_specific_info_len =
1540 hidl_request.baseConfigs.serviceSpecificInfo.size();
1541 if (legacy_request->service_specific_info_len >
1542 NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1543 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1544 "service_specific_info_len too large";
1545 return false;
1546 }
1547 memcpy(legacy_request->service_specific_info,
1548 hidl_request.baseConfigs.serviceSpecificInfo.data(),
1549 legacy_request->service_specific_info_len);
1550 legacy_request->sdea_service_specific_info_len =
Etan Cohena7543a72017-02-17 13:46:19 -08001551 hidl_request.baseConfigs.extendedServiceSpecificInfo.size();
Roshan Piusabcf78f2017-10-06 16:30:38 -07001552 if (legacy_request->sdea_service_specific_info_len >
1553 NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1554 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1555 "sdea_service_specific_info_len too large";
1556 return false;
1557 }
1558 memcpy(legacy_request->sdea_service_specific_info,
1559 hidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
1560 legacy_request->sdea_service_specific_info_len);
1561 legacy_request->rx_match_filter_len =
1562 hidl_request.baseConfigs.rxMatchFilter.size();
1563 if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1564 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1565 "rx_match_filter_len too large";
1566 return false;
1567 }
1568 memcpy(legacy_request->rx_match_filter,
1569 hidl_request.baseConfigs.rxMatchFilter.data(),
1570 legacy_request->rx_match_filter_len);
1571 legacy_request->tx_match_filter_len =
1572 hidl_request.baseConfigs.txMatchFilter.size();
1573 if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1574 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1575 "tx_match_filter_len too large";
1576 return false;
1577 }
1578 memcpy(legacy_request->tx_match_filter,
1579 hidl_request.baseConfigs.txMatchFilter.data(),
1580 legacy_request->tx_match_filter_len);
1581 legacy_request->rssi_threshold_flag =
1582 hidl_request.baseConfigs.useRssiThreshold;
1583 legacy_request->recv_indication_cfg = 0;
1584 legacy_request->recv_indication_cfg |=
1585 hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1
1586 : 0x0;
1587 legacy_request->recv_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001588 hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001589 legacy_request->recv_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001590 hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001591 legacy_request->recv_indication_cfg |= 0x8;
1592 legacy_request->cipher_type =
1593 (unsigned int)hidl_request.baseConfigs.securityConfig.cipherType;
1594 if (hidl_request.baseConfigs.securityConfig.securityType ==
1595 NanDataPathSecurityType::PMK) {
1596 legacy_request->key_info.key_type =
1597 legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1598 legacy_request->key_info.body.pmk_info.pmk_len =
1599 hidl_request.baseConfigs.securityConfig.pmk.size();
1600 if (legacy_request->key_info.body.pmk_info.pmk_len !=
1601 NAN_PMK_INFO_LEN) {
1602 LOG(ERROR)
1603 << "convertHidlNanPublishRequestToLegacy: invalid pmk_len";
1604 return false;
1605 }
1606 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1607 hidl_request.baseConfigs.securityConfig.pmk.data(),
1608 legacy_request->key_info.body.pmk_info.pmk_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001609 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001610 if (hidl_request.baseConfigs.securityConfig.securityType ==
1611 NanDataPathSecurityType::PASSPHRASE) {
1612 legacy_request->key_info.key_type =
1613 legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1614 legacy_request->key_info.body.passphrase_info.passphrase_len =
1615 hidl_request.baseConfigs.securityConfig.passphrase.size();
1616 if (legacy_request->key_info.body.passphrase_info.passphrase_len <
1617 NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1618 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1619 "passphrase_len too small";
1620 return false;
1621 }
1622 if (legacy_request->key_info.body.passphrase_info.passphrase_len >
1623 NAN_SECURITY_MAX_PASSPHRASE_LEN) {
1624 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1625 "passphrase_len too large";
1626 return false;
1627 }
1628 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1629 hidl_request.baseConfigs.securityConfig.passphrase.data(),
1630 legacy_request->key_info.body.passphrase_info.passphrase_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001631 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001632 legacy_request->sdea_params.security_cfg =
1633 (hidl_request.baseConfigs.securityConfig.securityType !=
1634 NanDataPathSecurityType::OPEN)
1635 ? legacy_hal::NAN_DP_CONFIG_SECURITY
Etan Cohenc58619e2017-03-14 14:54:40 -07001636 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001637 legacy_request->sdea_params.ranging_state =
1638 hidl_request.baseConfigs.rangingRequired
1639 ? legacy_hal::NAN_RANGING_ENABLE
1640 : legacy_hal::NAN_RANGING_DISABLE;
1641 legacy_request->ranging_cfg.ranging_interval_msec =
1642 hidl_request.baseConfigs.rangingIntervalMsec;
1643 legacy_request->ranging_cfg.config_ranging_indications =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001644 hidl_request.baseConfigs.configRangingIndications;
Etan Cohen7b8c5d72017-12-14 18:12:04 -08001645 legacy_request->ranging_cfg.distance_ingress_mm =
1646 hidl_request.baseConfigs.distanceIngressCm * 10;
1647 legacy_request->ranging_cfg.distance_egress_mm =
1648 hidl_request.baseConfigs.distanceEgressCm * 10;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001649 legacy_request->ranging_auto_response =
1650 hidl_request.baseConfigs.rangingRequired
1651 ? legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE
1652 : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
1653 legacy_request->sdea_params.range_report =
1654 legacy_hal::NAN_DISABLE_RANGE_REPORT;
1655 legacy_request->publish_type =
1656 convertHidlNanPublishTypeToLegacy(hidl_request.publishType);
1657 legacy_request->tx_type = convertHidlNanTxTypeToLegacy(hidl_request.txType);
1658 legacy_request->service_responder_policy =
1659 hidl_request.autoAcceptDataPathRequests
1660 ? legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL
1661 : legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001662
Roshan Piusabcf78f2017-10-06 16:30:38 -07001663 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001664}
1665
1666bool convertHidlNanSubscribeRequestToLegacy(
1667 const NanSubscribeRequest& hidl_request,
1668 legacy_hal::NanSubscribeRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001669 if (!legacy_request) {
1670 LOG(ERROR)
1671 << "convertHidlNanSubscribeRequestToLegacy: legacy_request is null";
1672 return false;
1673 }
1674 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001675
Roshan Piusabcf78f2017-10-06 16:30:38 -07001676 legacy_request->subscribe_id = hidl_request.baseConfigs.sessionId;
1677 legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
1678 legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
1679 legacy_request->subscribe_count = hidl_request.baseConfigs.discoveryCount;
1680 legacy_request->service_name_len =
1681 hidl_request.baseConfigs.serviceName.size();
1682 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1683 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1684 "service_name_len too large";
1685 return false;
1686 }
1687 memcpy(legacy_request->service_name,
1688 hidl_request.baseConfigs.serviceName.data(),
1689 legacy_request->service_name_len);
1690 legacy_request->subscribe_match_indicator = convertHidlNanMatchAlgToLegacy(
1691 hidl_request.baseConfigs.discoveryMatchIndicator);
1692 legacy_request->service_specific_info_len =
1693 hidl_request.baseConfigs.serviceSpecificInfo.size();
1694 if (legacy_request->service_specific_info_len >
1695 NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1696 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1697 "service_specific_info_len too large";
1698 return false;
1699 }
1700 memcpy(legacy_request->service_specific_info,
1701 hidl_request.baseConfigs.serviceSpecificInfo.data(),
1702 legacy_request->service_specific_info_len);
1703 legacy_request->sdea_service_specific_info_len =
Etan Cohena7543a72017-02-17 13:46:19 -08001704 hidl_request.baseConfigs.extendedServiceSpecificInfo.size();
Roshan Piusabcf78f2017-10-06 16:30:38 -07001705 if (legacy_request->sdea_service_specific_info_len >
1706 NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1707 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1708 "sdea_service_specific_info_len too large";
1709 return false;
1710 }
1711 memcpy(legacy_request->sdea_service_specific_info,
1712 hidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
1713 legacy_request->sdea_service_specific_info_len);
1714 legacy_request->rx_match_filter_len =
1715 hidl_request.baseConfigs.rxMatchFilter.size();
1716 if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1717 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1718 "rx_match_filter_len too large";
1719 return false;
1720 }
1721 memcpy(legacy_request->rx_match_filter,
1722 hidl_request.baseConfigs.rxMatchFilter.data(),
1723 legacy_request->rx_match_filter_len);
1724 legacy_request->tx_match_filter_len =
1725 hidl_request.baseConfigs.txMatchFilter.size();
1726 if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1727 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1728 "tx_match_filter_len too large";
1729 return false;
1730 }
1731 memcpy(legacy_request->tx_match_filter,
1732 hidl_request.baseConfigs.txMatchFilter.data(),
1733 legacy_request->tx_match_filter_len);
1734 legacy_request->rssi_threshold_flag =
1735 hidl_request.baseConfigs.useRssiThreshold;
1736 legacy_request->recv_indication_cfg = 0;
1737 legacy_request->recv_indication_cfg |=
1738 hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1
1739 : 0x0;
1740 legacy_request->recv_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001741 hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001742 legacy_request->recv_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001743 hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001744 legacy_request->cipher_type =
1745 (unsigned int)hidl_request.baseConfigs.securityConfig.cipherType;
1746 if (hidl_request.baseConfigs.securityConfig.securityType ==
1747 NanDataPathSecurityType::PMK) {
1748 legacy_request->key_info.key_type =
1749 legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1750 legacy_request->key_info.body.pmk_info.pmk_len =
1751 hidl_request.baseConfigs.securityConfig.pmk.size();
1752 if (legacy_request->key_info.body.pmk_info.pmk_len !=
1753 NAN_PMK_INFO_LEN) {
1754 LOG(ERROR)
1755 << "convertHidlNanSubscribeRequestToLegacy: invalid pmk_len";
1756 return false;
1757 }
1758 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1759 hidl_request.baseConfigs.securityConfig.pmk.data(),
1760 legacy_request->key_info.body.pmk_info.pmk_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001761 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001762 if (hidl_request.baseConfigs.securityConfig.securityType ==
1763 NanDataPathSecurityType::PASSPHRASE) {
1764 legacy_request->key_info.key_type =
1765 legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1766 legacy_request->key_info.body.passphrase_info.passphrase_len =
1767 hidl_request.baseConfigs.securityConfig.passphrase.size();
1768 if (legacy_request->key_info.body.passphrase_info.passphrase_len <
1769 NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1770 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1771 "passphrase_len too small";
1772 return false;
1773 }
1774 if (legacy_request->key_info.body.passphrase_info.passphrase_len >
1775 NAN_SECURITY_MAX_PASSPHRASE_LEN) {
1776 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1777 "passphrase_len too large";
1778 return false;
1779 }
1780 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1781 hidl_request.baseConfigs.securityConfig.passphrase.data(),
1782 legacy_request->key_info.body.passphrase_info.passphrase_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001783 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001784 legacy_request->sdea_params.security_cfg =
1785 (hidl_request.baseConfigs.securityConfig.securityType !=
1786 NanDataPathSecurityType::OPEN)
1787 ? legacy_hal::NAN_DP_CONFIG_SECURITY
1788 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
1789 legacy_request->sdea_params.ranging_state =
1790 hidl_request.baseConfigs.rangingRequired
1791 ? legacy_hal::NAN_RANGING_ENABLE
1792 : legacy_hal::NAN_RANGING_DISABLE;
1793 legacy_request->ranging_cfg.ranging_interval_msec =
1794 hidl_request.baseConfigs.rangingIntervalMsec;
1795 legacy_request->ranging_cfg.config_ranging_indications =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001796 hidl_request.baseConfigs.configRangingIndications;
Etan Cohen7b8c5d72017-12-14 18:12:04 -08001797 legacy_request->ranging_cfg.distance_ingress_mm =
1798 hidl_request.baseConfigs.distanceIngressCm * 10;
1799 legacy_request->ranging_cfg.distance_egress_mm =
1800 hidl_request.baseConfigs.distanceEgressCm * 10;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001801 legacy_request->ranging_auto_response =
1802 hidl_request.baseConfigs.rangingRequired
1803 ? legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE
1804 : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
1805 legacy_request->sdea_params.range_report =
1806 legacy_hal::NAN_DISABLE_RANGE_REPORT;
1807 legacy_request->subscribe_type =
1808 convertHidlNanSubscribeTypeToLegacy(hidl_request.subscribeType);
1809 legacy_request->serviceResponseFilter =
1810 convertHidlNanSrfTypeToLegacy(hidl_request.srfType);
1811 legacy_request->serviceResponseInclude =
1812 hidl_request.srfRespondIfInAddressSet
1813 ? legacy_hal::NAN_SRF_INCLUDE_RESPOND
1814 : legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
1815 legacy_request->useServiceResponseFilter =
1816 hidl_request.shouldUseSrf ? legacy_hal::NAN_USE_SRF
1817 : legacy_hal::NAN_DO_NOT_USE_SRF;
1818 legacy_request->ssiRequiredForMatchIndication =
1819 hidl_request.isSsiRequiredForMatch
1820 ? legacy_hal::NAN_SSI_REQUIRED_IN_MATCH_IND
1821 : legacy_hal::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND;
1822 legacy_request->num_intf_addr_present = hidl_request.intfAddr.size();
1823 if (legacy_request->num_intf_addr_present > NAN_MAX_SUBSCRIBE_MAX_ADDRESS) {
1824 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1825 "num_intf_addr_present - too many";
1826 return false;
1827 }
1828 for (int i = 0; i < legacy_request->num_intf_addr_present; i++) {
1829 memcpy(legacy_request->intf_addr[i], hidl_request.intfAddr[i].data(),
1830 6);
1831 }
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001832
Roshan Piusabcf78f2017-10-06 16:30:38 -07001833 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001834}
1835
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001836bool convertHidlNanTransmitFollowupRequestToLegacy(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001837 const NanTransmitFollowupRequest& hidl_request,
1838 legacy_hal::NanTransmitFollowupRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001839 if (!legacy_request) {
1840 LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
1841 "legacy_request is null";
1842 return false;
1843 }
1844 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001845
Roshan Piusabcf78f2017-10-06 16:30:38 -07001846 legacy_request->publish_subscribe_id = hidl_request.discoverySessionId;
1847 legacy_request->requestor_instance_id = hidl_request.peerId;
1848 memcpy(legacy_request->addr, hidl_request.addr.data(), 6);
1849 legacy_request->priority = hidl_request.isHighPriority
1850 ? legacy_hal::NAN_TX_PRIORITY_HIGH
1851 : legacy_hal::NAN_TX_PRIORITY_NORMAL;
1852 legacy_request->dw_or_faw = hidl_request.shouldUseDiscoveryWindow
1853 ? legacy_hal::NAN_TRANSMIT_IN_DW
1854 : legacy_hal::NAN_TRANSMIT_IN_FAW;
1855 legacy_request->service_specific_info_len =
1856 hidl_request.serviceSpecificInfo.size();
1857 if (legacy_request->service_specific_info_len >
1858 NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1859 LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
1860 "service_specific_info_len too large";
1861 return false;
1862 }
1863 memcpy(legacy_request->service_specific_info,
1864 hidl_request.serviceSpecificInfo.data(),
1865 legacy_request->service_specific_info_len);
1866 legacy_request->sdea_service_specific_info_len =
1867 hidl_request.extendedServiceSpecificInfo.size();
1868 if (legacy_request->sdea_service_specific_info_len >
1869 NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1870 LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
1871 "sdea_service_specific_info_len too large";
1872 return false;
1873 }
1874 memcpy(legacy_request->sdea_service_specific_info,
1875 hidl_request.extendedServiceSpecificInfo.data(),
1876 legacy_request->sdea_service_specific_info_len);
1877 legacy_request->recv_indication_cfg =
1878 hidl_request.disableFollowupResultIndication ? 0x1 : 0x0;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001879
Roshan Piusabcf78f2017-10-06 16:30:38 -07001880 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001881}
1882
1883bool convertHidlNanConfigRequestToLegacy(
Jimmy Chend460df32019-11-29 17:31:22 +02001884 const V1_4::NanConfigRequest& hidl_request,
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001885 legacy_hal::NanConfigRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001886 if (!legacy_request) {
1887 LOG(ERROR)
1888 << "convertHidlNanConfigRequestToLegacy: legacy_request is null";
1889 return false;
1890 }
1891 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001892
Roshan Piusabcf78f2017-10-06 16:30:38 -07001893 // TODO: b/34059183 tracks missing configurations in legacy HAL or uknown
1894 // defaults
1895 legacy_request->master_pref = hidl_request.masterPref;
1896 legacy_request->discovery_indication_cfg = 0;
1897 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001898 hidl_request.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001899 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001900 hidl_request.disableStartedClusterIndication ? 0x2 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001901 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001902 hidl_request.disableJoinedClusterIndication ? 0x4 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001903 legacy_request->config_sid_beacon = 1;
1904 if (hidl_request.numberOfPublishServiceIdsInBeacon > 127) {
1905 LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: "
1906 "numberOfPublishServiceIdsInBeacon > 127";
1907 return false;
1908 }
1909 legacy_request->sid_beacon =
1910 (hidl_request.includePublishServiceIdsInBeacon ? 0x1 : 0x0) |
1911 (hidl_request.numberOfPublishServiceIdsInBeacon << 1);
1912 legacy_request->config_subscribe_sid_beacon = 1;
1913 if (hidl_request.numberOfSubscribeServiceIdsInBeacon > 127) {
1914 LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: "
1915 "numberOfSubscribeServiceIdsInBeacon > 127";
1916 return false;
1917 }
1918 legacy_request->subscribe_sid_beacon_val =
1919 (hidl_request.includeSubscribeServiceIdsInBeacon ? 0x1 : 0x0) |
1920 (hidl_request.numberOfSubscribeServiceIdsInBeacon << 1);
1921 legacy_request->config_rssi_window_size = 1;
1922 legacy_request->rssi_window_size_val = hidl_request.rssiWindowSize;
1923 legacy_request->config_disc_mac_addr_randomization = 1;
1924 legacy_request->disc_mac_addr_rand_interval_sec =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001925 hidl_request.macAddressRandomizationIntervalSec;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001926 /* TODO : missing
1927 legacy_request->config_2dot4g_rssi_close = 1;
1928 legacy_request->rssi_close_2dot4g_val =
1929 hidl_request.bandSpecificConfig[
1930 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiClose;
1931 legacy_request->config_2dot4g_rssi_middle = 1;
1932 legacy_request->rssi_middle_2dot4g_val =
1933 hidl_request.bandSpecificConfig[
1934 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiMiddle;
1935 legacy_request->config_2dot4g_rssi_proximity = 1;
1936 legacy_request->rssi_proximity_2dot4g_val =
1937 hidl_request.bandSpecificConfig[
1938 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiCloseProximity;
1939 */
1940 legacy_request->config_scan_params = 1;
1941 legacy_request->scan_params_val
1942 .dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
1943 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1944 .dwellTimeMs;
1945 legacy_request->scan_params_val
1946 .scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
1947 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1948 .scanPeriodSec;
1949 legacy_request->config_dw.config_2dot4g_dw_band =
1950 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1951 .validDiscoveryWindowIntervalVal;
1952 legacy_request->config_dw.dw_2dot4g_interval_val =
1953 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1954 .discoveryWindowIntervalVal;
1955 /* TODO: missing
1956 legacy_request->config_5g_rssi_close = 1;
1957 legacy_request->rssi_close_5g_val =
1958 hidl_request.bandSpecificConfig[
1959 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiClose;
1960 legacy_request->config_5g_rssi_middle = 1;
1961 legacy_request->rssi_middle_5g_val =
1962 hidl_request.bandSpecificConfig[
1963 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiMiddle;
1964 */
1965 legacy_request->config_5g_rssi_close_proximity = 1;
1966 legacy_request->rssi_close_proximity_5g_val =
1967 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1968 .rssiCloseProximity;
1969 legacy_request->scan_params_val
1970 .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1971 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1972 .dwellTimeMs;
1973 legacy_request->scan_params_val
1974 .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1975 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1976 .scanPeriodSec;
1977 legacy_request->scan_params_val
1978 .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1979 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1980 .dwellTimeMs;
1981 legacy_request->scan_params_val
1982 .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1983 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1984 .scanPeriodSec;
1985 legacy_request->config_dw.config_5g_dw_band =
1986 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1987 .validDiscoveryWindowIntervalVal;
1988 legacy_request->config_dw.dw_5g_interval_val =
1989 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1990 .discoveryWindowIntervalVal;
Ahmed ElArabawy83baffd2019-11-15 19:20:41 -08001991 /* TODO: b/145609058
1992 * Missing updates needed to legacy_hal::NanConfigRequest and conversion to
1993 * it for 6GHz band */
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001994
Roshan Piusabcf78f2017-10-06 16:30:38 -07001995 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001996}
1997
Ahmed ElArabawy83baffd2019-11-15 19:20:41 -08001998bool convertHidlNanConfigRequest_1_4ToLegacy(
Jimmy Chend460df32019-11-29 17:31:22 +02001999 const V1_4::NanConfigRequest& hidl_request1,
Nate Jiang3ec67812020-08-24 11:04:31 -07002000 const NanConfigRequestSupplemental& hidl_request2,
Etan Cohen9e7a4052017-12-21 13:45:26 -08002001 legacy_hal::NanConfigRequest* legacy_request) {
2002 if (!legacy_request) {
Ahmed ElArabawy83baffd2019-11-15 19:20:41 -08002003 LOG(ERROR) << "convertHidlNanConfigRequest_1_4ToLegacy: legacy_request "
Etan Cohen9e7a4052017-12-21 13:45:26 -08002004 "is null";
2005 return false;
2006 }
2007
2008 *legacy_request = {};
2009 if (!convertHidlNanConfigRequestToLegacy(hidl_request1, legacy_request)) {
2010 return false;
2011 }
2012
2013 legacy_request->config_discovery_beacon_int = 1;
2014 legacy_request->discovery_beacon_interval =
Nate Jiang3ec67812020-08-24 11:04:31 -07002015 hidl_request2.V1_2.discoveryBeaconIntervalMs;
Etan Cohen9e7a4052017-12-21 13:45:26 -08002016 legacy_request->config_nss = 1;
Nate Jiang3ec67812020-08-24 11:04:31 -07002017 legacy_request->nss = hidl_request2.V1_2.numberOfSpatialStreamsInDiscovery;
Etan Cohen9e7a4052017-12-21 13:45:26 -08002018 legacy_request->config_dw_early_termination = 1;
2019 legacy_request->enable_dw_termination =
Nate Jiang3ec67812020-08-24 11:04:31 -07002020 hidl_request2.V1_2.enableDiscoveryWindowEarlyTermination;
Etan Cohen4f5bc6c2017-12-28 13:08:08 -08002021 legacy_request->config_enable_ranging = 1;
Nate Jiang3ec67812020-08-24 11:04:31 -07002022 legacy_request->enable_ranging = hidl_request2.V1_2.enableRanging;
Etan Cohen9e7a4052017-12-21 13:45:26 -08002023
2024 return true;
2025}
2026
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002027bool convertHidlNanDataPathInitiatorRequestToLegacy(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002028 const NanInitiateDataPathRequest& hidl_request,
2029 legacy_hal::NanDataPathInitiatorRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002030 if (!legacy_request) {
2031 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
2032 "legacy_request is null";
2033 return false;
2034 }
2035 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002036
Roshan Piusabcf78f2017-10-06 16:30:38 -07002037 legacy_request->requestor_instance_id = hidl_request.peerId;
2038 memcpy(legacy_request->peer_disc_mac_addr,
2039 hidl_request.peerDiscMacAddr.data(), 6);
2040 legacy_request->channel_request_type =
2041 convertHidlNanDataPathChannelCfgToLegacy(
2042 hidl_request.channelRequestType);
2043 legacy_request->channel = hidl_request.channel;
Etan Cohen1cefaf62019-11-25 11:41:58 -08002044 if (strnlen(hidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
2045 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
2046 "ifaceName too long";
2047 return false;
2048 }
2049 strncpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str(),
2050 IFNAMSIZ + 1);
Roshan Piusabcf78f2017-10-06 16:30:38 -07002051 legacy_request->ndp_cfg.security_cfg =
2052 (hidl_request.securityConfig.securityType !=
2053 NanDataPathSecurityType::OPEN)
2054 ? legacy_hal::NAN_DP_CONFIG_SECURITY
Etan Cohenc58619e2017-03-14 14:54:40 -07002055 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002056 legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
2057 if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
2058 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
2059 "ndp_app_info_len too large";
2060 return false;
Etan Cohenc58619e2017-03-14 14:54:40 -07002061 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002062 memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
2063 legacy_request->app_info.ndp_app_info_len);
2064 legacy_request->cipher_type =
2065 (unsigned int)hidl_request.securityConfig.cipherType;
2066 if (hidl_request.securityConfig.securityType ==
2067 NanDataPathSecurityType::PMK) {
2068 legacy_request->key_info.key_type =
2069 legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
2070 legacy_request->key_info.body.pmk_info.pmk_len =
2071 hidl_request.securityConfig.pmk.size();
2072 if (legacy_request->key_info.body.pmk_info.pmk_len !=
2073 NAN_PMK_INFO_LEN) {
2074 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
2075 "invalid pmk_len";
2076 return false;
2077 }
2078 memcpy(legacy_request->key_info.body.pmk_info.pmk,
2079 hidl_request.securityConfig.pmk.data(),
2080 legacy_request->key_info.body.pmk_info.pmk_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07002081 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002082 if (hidl_request.securityConfig.securityType ==
2083 NanDataPathSecurityType::PASSPHRASE) {
2084 legacy_request->key_info.key_type =
2085 legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
2086 legacy_request->key_info.body.passphrase_info.passphrase_len =
2087 hidl_request.securityConfig.passphrase.size();
2088 if (legacy_request->key_info.body.passphrase_info.passphrase_len <
2089 NAN_SECURITY_MIN_PASSPHRASE_LEN) {
2090 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
2091 "passphrase_len too small";
2092 return false;
2093 }
2094 if (legacy_request->key_info.body.passphrase_info.passphrase_len >
2095 NAN_SECURITY_MAX_PASSPHRASE_LEN) {
2096 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
2097 "passphrase_len too large";
2098 return false;
2099 }
2100 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
2101 hidl_request.securityConfig.passphrase.data(),
2102 legacy_request->key_info.body.passphrase_info.passphrase_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07002103 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002104 legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
2105 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
2106 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
2107 "service_name_len too large";
2108 return false;
2109 }
2110 memcpy(legacy_request->service_name,
2111 hidl_request.serviceNameOutOfBand.data(),
2112 legacy_request->service_name_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002113
Roshan Piusabcf78f2017-10-06 16:30:38 -07002114 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002115}
2116
2117bool convertHidlNanDataPathIndicationResponseToLegacy(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002118 const NanRespondToDataPathIndicationRequest& hidl_request,
2119 legacy_hal::NanDataPathIndicationResponse* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002120 if (!legacy_request) {
2121 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2122 "legacy_request is null";
2123 return false;
2124 }
2125 *legacy_request = {};
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002126
Roshan Piusabcf78f2017-10-06 16:30:38 -07002127 legacy_request->rsp_code = hidl_request.acceptRequest
2128 ? legacy_hal::NAN_DP_REQUEST_ACCEPT
2129 : legacy_hal::NAN_DP_REQUEST_REJECT;
2130 legacy_request->ndp_instance_id = hidl_request.ndpInstanceId;
Etan Cohen1cefaf62019-11-25 11:41:58 -08002131 if (strnlen(hidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
2132 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2133 "ifaceName too long";
2134 return false;
2135 }
2136 strncpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str(),
2137 IFNAMSIZ + 1);
Roshan Piusabcf78f2017-10-06 16:30:38 -07002138 legacy_request->ndp_cfg.security_cfg =
2139 (hidl_request.securityConfig.securityType !=
2140 NanDataPathSecurityType::OPEN)
2141 ? legacy_hal::NAN_DP_CONFIG_SECURITY
Etan Cohenc58619e2017-03-14 14:54:40 -07002142 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002143 legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
2144 if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
2145 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2146 "ndp_app_info_len too large";
2147 return false;
Etan Cohenc58619e2017-03-14 14:54:40 -07002148 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002149 memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
2150 legacy_request->app_info.ndp_app_info_len);
2151 legacy_request->cipher_type =
2152 (unsigned int)hidl_request.securityConfig.cipherType;
2153 if (hidl_request.securityConfig.securityType ==
2154 NanDataPathSecurityType::PMK) {
2155 legacy_request->key_info.key_type =
2156 legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
2157 legacy_request->key_info.body.pmk_info.pmk_len =
2158 hidl_request.securityConfig.pmk.size();
2159 if (legacy_request->key_info.body.pmk_info.pmk_len !=
2160 NAN_PMK_INFO_LEN) {
2161 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2162 "invalid pmk_len";
2163 return false;
2164 }
2165 memcpy(legacy_request->key_info.body.pmk_info.pmk,
2166 hidl_request.securityConfig.pmk.data(),
2167 legacy_request->key_info.body.pmk_info.pmk_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07002168 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002169 if (hidl_request.securityConfig.securityType ==
2170 NanDataPathSecurityType::PASSPHRASE) {
2171 legacy_request->key_info.key_type =
2172 legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
2173 legacy_request->key_info.body.passphrase_info.passphrase_len =
2174 hidl_request.securityConfig.passphrase.size();
2175 if (legacy_request->key_info.body.passphrase_info.passphrase_len <
2176 NAN_SECURITY_MIN_PASSPHRASE_LEN) {
2177 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2178 "passphrase_len too small";
2179 return false;
2180 }
2181 if (legacy_request->key_info.body.passphrase_info.passphrase_len >
2182 NAN_SECURITY_MAX_PASSPHRASE_LEN) {
2183 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2184 "passphrase_len too large";
2185 return false;
2186 }
2187 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
2188 hidl_request.securityConfig.passphrase.data(),
2189 legacy_request->key_info.body.passphrase_info.passphrase_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07002190 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002191 legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
2192 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
2193 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2194 "service_name_len too large";
2195 return false;
2196 }
2197 memcpy(legacy_request->service_name,
2198 hidl_request.serviceNameOutOfBand.data(),
2199 legacy_request->service_name_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002200
Roshan Piusabcf78f2017-10-06 16:30:38 -07002201 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002202}
2203
2204bool convertLegacyNanResponseHeaderToHidl(
2205 const legacy_hal::NanResponseMsg& legacy_response,
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002206 WifiNanStatus* wifiNanStatus) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002207 if (!wifiNanStatus) {
2208 LOG(ERROR)
2209 << "convertLegacyNanResponseHeaderToHidl: wifiNanStatus is null";
2210 return false;
2211 }
2212 *wifiNanStatus = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002213
Roshan Piusabcf78f2017-10-06 16:30:38 -07002214 convertToWifiNanStatus(legacy_response.status, legacy_response.nan_error,
2215 sizeof(legacy_response.nan_error), wifiNanStatus);
2216 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002217}
2218
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002219bool convertLegacyNanCapabilitiesResponseToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002220 const legacy_hal::NanCapabilities& legacy_response,
2221 NanCapabilities* hidl_response) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002222 if (!hidl_response) {
2223 LOG(ERROR) << "convertLegacyNanCapabilitiesResponseToHidl: "
2224 "hidl_response is null";
2225 return false;
2226 }
2227 *hidl_response = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002228
Nate Jiang3ec67812020-08-24 11:04:31 -07002229 hidl_response->V1_0.maxConcurrentClusters =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002230 legacy_response.max_concurrent_nan_clusters;
Nate Jiang3ec67812020-08-24 11:04:31 -07002231 hidl_response->V1_0.maxPublishes = legacy_response.max_publishes;
2232 hidl_response->V1_0.maxSubscribes = legacy_response.max_subscribes;
2233 hidl_response->V1_0.maxServiceNameLen =
2234 legacy_response.max_service_name_len;
2235 hidl_response->V1_0.maxMatchFilterLen =
2236 legacy_response.max_match_filter_len;
2237 hidl_response->V1_0.maxTotalMatchFilterLen =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002238 legacy_response.max_total_match_filter_len;
Nate Jiang3ec67812020-08-24 11:04:31 -07002239 hidl_response->V1_0.maxServiceSpecificInfoLen =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002240 legacy_response.max_service_specific_info_len;
Nate Jiang3ec67812020-08-24 11:04:31 -07002241 hidl_response->V1_0.maxExtendedServiceSpecificInfoLen =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002242 legacy_response.max_sdea_service_specific_info_len;
Nate Jiang3ec67812020-08-24 11:04:31 -07002243 hidl_response->V1_0.maxNdiInterfaces = legacy_response.max_ndi_interfaces;
2244 hidl_response->V1_0.maxNdpSessions = legacy_response.max_ndp_sessions;
2245 hidl_response->V1_0.maxAppInfoLen = legacy_response.max_app_info_len;
2246 hidl_response->V1_0.maxQueuedTransmitFollowupMsgs =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002247 legacy_response.max_queued_transmit_followup_msgs;
Nate Jiang3ec67812020-08-24 11:04:31 -07002248 hidl_response->V1_0.maxSubscribeInterfaceAddresses =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002249 legacy_response.max_subscribe_address;
Nate Jiang3ec67812020-08-24 11:04:31 -07002250 hidl_response->V1_0.supportedCipherSuites =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002251 legacy_response.cipher_suites_supported;
Nate Jiang3ec67812020-08-24 11:04:31 -07002252 hidl_response->instantCommunicationModeSupportFlag =
2253 legacy_response.is_instant_mode_supported;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002254
Roshan Piusabcf78f2017-10-06 16:30:38 -07002255 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002256}
2257
Roshan Piusabcf78f2017-10-06 16:30:38 -07002258bool convertLegacyNanMatchIndToHidl(const legacy_hal::NanMatchInd& legacy_ind,
2259 NanMatchInd* hidl_ind) {
2260 if (!hidl_ind) {
2261 LOG(ERROR) << "convertLegacyNanMatchIndToHidl: hidl_ind is null";
2262 return false;
2263 }
2264 *hidl_ind = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002265
Roshan Piusabcf78f2017-10-06 16:30:38 -07002266 hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
2267 hidl_ind->peerId = legacy_ind.requestor_instance_id;
2268 hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
2269 hidl_ind->serviceSpecificInfo =
2270 std::vector<uint8_t>(legacy_ind.service_specific_info,
2271 legacy_ind.service_specific_info +
2272 legacy_ind.service_specific_info_len);
2273 hidl_ind->extendedServiceSpecificInfo =
2274 std::vector<uint8_t>(legacy_ind.sdea_service_specific_info,
2275 legacy_ind.sdea_service_specific_info +
2276 legacy_ind.sdea_service_specific_info_len);
2277 hidl_ind->matchFilter = std::vector<uint8_t>(
2278 legacy_ind.sdf_match_filter,
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002279 legacy_ind.sdf_match_filter + legacy_ind.sdf_match_filter_len);
Roshan Piusabcf78f2017-10-06 16:30:38 -07002280 hidl_ind->matchOccuredInBeaconFlag = legacy_ind.match_occured_flag == 1;
2281 hidl_ind->outOfResourceFlag = legacy_ind.out_of_resource_flag == 1;
2282 hidl_ind->rssiValue = legacy_ind.rssi_value;
2283 hidl_ind->peerCipherType = (NanCipherSuiteType)legacy_ind.peer_cipher_type;
2284 hidl_ind->peerRequiresSecurityEnabledInNdp =
2285 legacy_ind.peer_sdea_params.security_cfg ==
2286 legacy_hal::NAN_DP_CONFIG_SECURITY;
2287 hidl_ind->peerRequiresRanging = legacy_ind.peer_sdea_params.ranging_state ==
2288 legacy_hal::NAN_RANGING_ENABLE;
2289 hidl_ind->rangingMeasurementInCm =
Etan Cohen7b8c5d72017-12-14 18:12:04 -08002290 legacy_ind.range_info.range_measurement_mm / 10;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002291 hidl_ind->rangingIndicationType = legacy_ind.range_info.ranging_event_type;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002292
Roshan Piusabcf78f2017-10-06 16:30:38 -07002293 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002294}
2295
2296bool convertLegacyNanFollowupIndToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002297 const legacy_hal::NanFollowupInd& legacy_ind,
2298 NanFollowupReceivedInd* hidl_ind) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002299 if (!hidl_ind) {
2300 LOG(ERROR) << "convertLegacyNanFollowupIndToHidl: hidl_ind is null";
2301 return false;
2302 }
2303 *hidl_ind = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002304
Roshan Piusabcf78f2017-10-06 16:30:38 -07002305 hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
2306 hidl_ind->peerId = legacy_ind.requestor_instance_id;
2307 hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
2308 hidl_ind->receivedInFaw = legacy_ind.dw_or_faw == 1;
2309 hidl_ind->serviceSpecificInfo =
2310 std::vector<uint8_t>(legacy_ind.service_specific_info,
2311 legacy_ind.service_specific_info +
2312 legacy_ind.service_specific_info_len);
2313 hidl_ind->extendedServiceSpecificInfo =
2314 std::vector<uint8_t>(legacy_ind.sdea_service_specific_info,
2315 legacy_ind.sdea_service_specific_info +
2316 legacy_ind.sdea_service_specific_info_len);
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002317
Roshan Piusabcf78f2017-10-06 16:30:38 -07002318 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002319}
2320
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002321bool convertLegacyNanDataPathRequestIndToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002322 const legacy_hal::NanDataPathRequestInd& legacy_ind,
2323 NanDataPathRequestInd* hidl_ind) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002324 if (!hidl_ind) {
2325 LOG(ERROR)
2326 << "convertLegacyNanDataPathRequestIndToHidl: hidl_ind is null";
2327 return false;
2328 }
2329 *hidl_ind = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002330
Roshan Piusabcf78f2017-10-06 16:30:38 -07002331 hidl_ind->discoverySessionId = legacy_ind.service_instance_id;
2332 hidl_ind->peerDiscMacAddr =
2333 hidl_array<uint8_t, 6>(legacy_ind.peer_disc_mac_addr);
2334 hidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
2335 hidl_ind->securityRequired =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002336 legacy_ind.ndp_cfg.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002337 hidl_ind->appInfo =
2338 std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info,
2339 legacy_ind.app_info.ndp_app_info +
2340 legacy_ind.app_info.ndp_app_info_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002341
Roshan Piusabcf78f2017-10-06 16:30:38 -07002342 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002343}
2344
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002345bool convertLegacyNdpChannelInfoToHidl(
2346 const legacy_hal::NanChannelInfo& legacy_struct,
Jong Wook Kimda830c92018-07-23 15:29:38 -07002347 V1_2::NanDataPathChannelInfo* hidl_struct) {
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002348 if (!hidl_struct) {
2349 LOG(ERROR) << "convertLegacyNdpChannelInfoToHidl: hidl_struct is null";
2350 return false;
2351 }
2352 *hidl_struct = {};
2353
2354 hidl_struct->channelFreq = legacy_struct.channel;
Etan Cohenb1b7a822018-02-07 14:44:32 -08002355 hidl_struct->channelBandwidth = convertLegacyWifiChannelWidthToHidl(
2356 (legacy_hal::wifi_channel_width)legacy_struct.bandwidth);
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002357 hidl_struct->numSpatialStreams = legacy_struct.nss;
2358
2359 return true;
2360}
2361
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002362bool convertLegacyNanDataPathConfirmIndToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002363 const legacy_hal::NanDataPathConfirmInd& legacy_ind,
Jong Wook Kimda830c92018-07-23 15:29:38 -07002364 V1_2::NanDataPathConfirmInd* hidl_ind) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002365 if (!hidl_ind) {
2366 LOG(ERROR)
2367 << "convertLegacyNanDataPathConfirmIndToHidl: hidl_ind is null";
2368 return false;
2369 }
2370 *hidl_ind = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002371
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002372 hidl_ind->V1_0.ndpInstanceId = legacy_ind.ndp_instance_id;
2373 hidl_ind->V1_0.dataPathSetupSuccess =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002374 legacy_ind.rsp_code == legacy_hal::NAN_DP_REQUEST_ACCEPT;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002375 hidl_ind->V1_0.peerNdiMacAddr =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002376 hidl_array<uint8_t, 6>(legacy_ind.peer_ndi_mac_addr);
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002377 hidl_ind->V1_0.appInfo =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002378 std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info,
2379 legacy_ind.app_info.ndp_app_info +
2380 legacy_ind.app_info.ndp_app_info_len);
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002381 hidl_ind->V1_0.status.status =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002382 convertLegacyNanStatusTypeToHidl(legacy_ind.reason_code);
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002383 hidl_ind->V1_0.status.description = ""; // TODO: b/34059183
2384
Jong Wook Kimda830c92018-07-23 15:29:38 -07002385 std::vector<V1_2::NanDataPathChannelInfo> channelInfo;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002386 for (unsigned int i = 0; i < legacy_ind.num_channels; ++i) {
Jong Wook Kimda830c92018-07-23 15:29:38 -07002387 V1_2::NanDataPathChannelInfo hidl_struct;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002388 if (!convertLegacyNdpChannelInfoToHidl(legacy_ind.channel_info[i],
2389 &hidl_struct)) {
2390 return false;
2391 }
2392 channelInfo.push_back(hidl_struct);
2393 }
2394 hidl_ind->channelInfo = channelInfo;
2395
2396 return true;
2397}
2398
2399bool convertLegacyNanDataPathScheduleUpdateIndToHidl(
2400 const legacy_hal::NanDataPathScheduleUpdateInd& legacy_ind,
Jong Wook Kimda830c92018-07-23 15:29:38 -07002401 V1_2::NanDataPathScheduleUpdateInd* hidl_ind) {
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002402 if (!hidl_ind) {
2403 LOG(ERROR) << "convertLegacyNanDataPathScheduleUpdateIndToHidl: "
2404 "hidl_ind is null";
2405 return false;
2406 }
2407 *hidl_ind = {};
2408
2409 hidl_ind->peerDiscoveryAddress =
2410 hidl_array<uint8_t, 6>(legacy_ind.peer_mac_addr);
Jong Wook Kimda830c92018-07-23 15:29:38 -07002411 std::vector<V1_2::NanDataPathChannelInfo> channelInfo;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002412 for (unsigned int i = 0; i < legacy_ind.num_channels; ++i) {
Jong Wook Kimda830c92018-07-23 15:29:38 -07002413 V1_2::NanDataPathChannelInfo hidl_struct;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002414 if (!convertLegacyNdpChannelInfoToHidl(legacy_ind.channel_info[i],
2415 &hidl_struct)) {
2416 return false;
2417 }
2418 channelInfo.push_back(hidl_struct);
2419 }
2420 hidl_ind->channelInfo = channelInfo;
2421 std::vector<uint32_t> ndpInstanceIds;
2422 for (unsigned int i = 0; i < legacy_ind.num_ndp_instances; ++i) {
2423 ndpInstanceIds.push_back(legacy_ind.ndp_instance_id[i]);
2424 }
2425 hidl_ind->ndpInstanceIds = ndpInstanceIds;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002426
Roshan Piusabcf78f2017-10-06 16:30:38 -07002427 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002428}
Roshan Pius3fae9c82016-12-02 14:49:41 -08002429
2430legacy_hal::wifi_rtt_type convertHidlRttTypeToLegacy(RttType type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002431 switch (type) {
2432 case RttType::ONE_SIDED:
2433 return legacy_hal::RTT_TYPE_1_SIDED;
2434 case RttType::TWO_SIDED:
2435 return legacy_hal::RTT_TYPE_2_SIDED;
2436 };
2437 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002438}
2439
2440RttType convertLegacyRttTypeToHidl(legacy_hal::wifi_rtt_type type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002441 switch (type) {
2442 case legacy_hal::RTT_TYPE_1_SIDED:
2443 return RttType::ONE_SIDED;
2444 case legacy_hal::RTT_TYPE_2_SIDED:
2445 return RttType::TWO_SIDED;
2446 };
2447 CHECK(false) << "Unknown legacy type: " << type;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002448}
2449
2450legacy_hal::rtt_peer_type convertHidlRttPeerTypeToLegacy(RttPeerType type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002451 switch (type) {
2452 case RttPeerType::AP:
2453 return legacy_hal::RTT_PEER_AP;
2454 case RttPeerType::STA:
2455 return legacy_hal::RTT_PEER_STA;
2456 case RttPeerType::P2P_GO:
2457 return legacy_hal::RTT_PEER_P2P_GO;
2458 case RttPeerType::P2P_CLIENT:
2459 return legacy_hal::RTT_PEER_P2P_CLIENT;
2460 case RttPeerType::NAN:
2461 return legacy_hal::RTT_PEER_NAN;
2462 };
2463 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002464}
2465
2466legacy_hal::wifi_channel_width convertHidlWifiChannelWidthToLegacy(
2467 WifiChannelWidthInMhz type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002468 switch (type) {
2469 case WifiChannelWidthInMhz::WIDTH_20:
2470 return legacy_hal::WIFI_CHAN_WIDTH_20;
2471 case WifiChannelWidthInMhz::WIDTH_40:
2472 return legacy_hal::WIFI_CHAN_WIDTH_40;
2473 case WifiChannelWidthInMhz::WIDTH_80:
2474 return legacy_hal::WIFI_CHAN_WIDTH_80;
2475 case WifiChannelWidthInMhz::WIDTH_160:
2476 return legacy_hal::WIFI_CHAN_WIDTH_160;
2477 case WifiChannelWidthInMhz::WIDTH_80P80:
2478 return legacy_hal::WIFI_CHAN_WIDTH_80P80;
2479 case WifiChannelWidthInMhz::WIDTH_5:
2480 return legacy_hal::WIFI_CHAN_WIDTH_5;
2481 case WifiChannelWidthInMhz::WIDTH_10:
2482 return legacy_hal::WIFI_CHAN_WIDTH_10;
2483 case WifiChannelWidthInMhz::WIDTH_INVALID:
2484 return legacy_hal::WIFI_CHAN_WIDTH_INVALID;
2485 };
2486 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002487}
2488
2489WifiChannelWidthInMhz convertLegacyWifiChannelWidthToHidl(
2490 legacy_hal::wifi_channel_width type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002491 switch (type) {
2492 case legacy_hal::WIFI_CHAN_WIDTH_20:
2493 return WifiChannelWidthInMhz::WIDTH_20;
2494 case legacy_hal::WIFI_CHAN_WIDTH_40:
2495 return WifiChannelWidthInMhz::WIDTH_40;
2496 case legacy_hal::WIFI_CHAN_WIDTH_80:
2497 return WifiChannelWidthInMhz::WIDTH_80;
2498 case legacy_hal::WIFI_CHAN_WIDTH_160:
2499 return WifiChannelWidthInMhz::WIDTH_160;
2500 case legacy_hal::WIFI_CHAN_WIDTH_80P80:
2501 return WifiChannelWidthInMhz::WIDTH_80P80;
2502 case legacy_hal::WIFI_CHAN_WIDTH_5:
2503 return WifiChannelWidthInMhz::WIDTH_5;
2504 case legacy_hal::WIFI_CHAN_WIDTH_10:
2505 return WifiChannelWidthInMhz::WIDTH_10;
2506 case legacy_hal::WIFI_CHAN_WIDTH_INVALID:
2507 return WifiChannelWidthInMhz::WIDTH_INVALID;
2508 };
2509 CHECK(false) << "Unknown legacy type: " << type;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002510}
2511
Jimmy Chend460df32019-11-29 17:31:22 +02002512legacy_hal::wifi_rtt_preamble convertHidlRttPreambleToLegacy(
2513 V1_4::RttPreamble type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002514 switch (type) {
Jimmy Chend460df32019-11-29 17:31:22 +02002515 case V1_4::RttPreamble::LEGACY:
Roshan Piusabcf78f2017-10-06 16:30:38 -07002516 return legacy_hal::WIFI_RTT_PREAMBLE_LEGACY;
Jimmy Chend460df32019-11-29 17:31:22 +02002517 case V1_4::RttPreamble::HT:
Roshan Piusabcf78f2017-10-06 16:30:38 -07002518 return legacy_hal::WIFI_RTT_PREAMBLE_HT;
Jimmy Chend460df32019-11-29 17:31:22 +02002519 case V1_4::RttPreamble::VHT:
Roshan Piusabcf78f2017-10-06 16:30:38 -07002520 return legacy_hal::WIFI_RTT_PREAMBLE_VHT;
Jimmy Chend460df32019-11-29 17:31:22 +02002521 case V1_4::RttPreamble::HE:
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07002522 return legacy_hal::WIFI_RTT_PREAMBLE_HE;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002523 };
2524 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002525}
2526
Jimmy Chend460df32019-11-29 17:31:22 +02002527V1_4::RttPreamble convertLegacyRttPreambleToHidl(
2528 legacy_hal::wifi_rtt_preamble type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002529 switch (type) {
2530 case legacy_hal::WIFI_RTT_PREAMBLE_LEGACY:
Jimmy Chend460df32019-11-29 17:31:22 +02002531 return V1_4::RttPreamble::LEGACY;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002532 case legacy_hal::WIFI_RTT_PREAMBLE_HT:
Jimmy Chend460df32019-11-29 17:31:22 +02002533 return V1_4::RttPreamble::HT;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002534 case legacy_hal::WIFI_RTT_PREAMBLE_VHT:
Jimmy Chend460df32019-11-29 17:31:22 +02002535 return V1_4::RttPreamble::VHT;
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07002536 case legacy_hal::WIFI_RTT_PREAMBLE_HE:
Jimmy Chend460df32019-11-29 17:31:22 +02002537 return V1_4::RttPreamble::HE;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002538 };
2539 CHECK(false) << "Unknown legacy type: " << type;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002540}
2541
2542legacy_hal::wifi_rtt_bw convertHidlRttBwToLegacy(RttBw type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002543 switch (type) {
2544 case RttBw::BW_5MHZ:
2545 return legacy_hal::WIFI_RTT_BW_5;
2546 case RttBw::BW_10MHZ:
2547 return legacy_hal::WIFI_RTT_BW_10;
2548 case RttBw::BW_20MHZ:
2549 return legacy_hal::WIFI_RTT_BW_20;
2550 case RttBw::BW_40MHZ:
2551 return legacy_hal::WIFI_RTT_BW_40;
2552 case RttBw::BW_80MHZ:
2553 return legacy_hal::WIFI_RTT_BW_80;
2554 case RttBw::BW_160MHZ:
2555 return legacy_hal::WIFI_RTT_BW_160;
2556 };
2557 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002558}
2559
2560RttBw convertLegacyRttBwToHidl(legacy_hal::wifi_rtt_bw type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002561 switch (type) {
2562 case legacy_hal::WIFI_RTT_BW_5:
2563 return RttBw::BW_5MHZ;
2564 case legacy_hal::WIFI_RTT_BW_10:
2565 return RttBw::BW_10MHZ;
2566 case legacy_hal::WIFI_RTT_BW_20:
2567 return RttBw::BW_20MHZ;
2568 case legacy_hal::WIFI_RTT_BW_40:
2569 return RttBw::BW_40MHZ;
2570 case legacy_hal::WIFI_RTT_BW_80:
2571 return RttBw::BW_80MHZ;
2572 case legacy_hal::WIFI_RTT_BW_160:
2573 return RttBw::BW_160MHZ;
2574 };
2575 CHECK(false) << "Unknown legacy type: " << type;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002576}
2577
2578legacy_hal::wifi_motion_pattern convertHidlRttMotionPatternToLegacy(
2579 RttMotionPattern type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002580 switch (type) {
2581 case RttMotionPattern::NOT_EXPECTED:
2582 return legacy_hal::WIFI_MOTION_NOT_EXPECTED;
2583 case RttMotionPattern::EXPECTED:
2584 return legacy_hal::WIFI_MOTION_EXPECTED;
2585 case RttMotionPattern::UNKNOWN:
2586 return legacy_hal::WIFI_MOTION_UNKNOWN;
2587 };
2588 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002589}
2590
Jimmy Chend460df32019-11-29 17:31:22 +02002591V1_4::WifiRatePreamble convertLegacyWifiRatePreambleToHidl(uint8_t preamble) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002592 switch (preamble) {
2593 case 0:
Jimmy Chend460df32019-11-29 17:31:22 +02002594 return V1_4::WifiRatePreamble::OFDM;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002595 case 1:
Jimmy Chend460df32019-11-29 17:31:22 +02002596 return V1_4::WifiRatePreamble::CCK;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002597 case 2:
Jimmy Chend460df32019-11-29 17:31:22 +02002598 return V1_4::WifiRatePreamble::HT;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002599 case 3:
Jimmy Chend460df32019-11-29 17:31:22 +02002600 return V1_4::WifiRatePreamble::VHT;
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07002601 case 4:
Jimmy Chend460df32019-11-29 17:31:22 +02002602 return V1_4::WifiRatePreamble::HE;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002603 default:
Jimmy Chend460df32019-11-29 17:31:22 +02002604 return V1_4::WifiRatePreamble::RESERVED;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002605 };
2606 CHECK(false) << "Unknown legacy preamble: " << preamble;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002607}
2608
2609WifiRateNss convertLegacyWifiRateNssToHidl(uint8_t nss) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002610 switch (nss) {
2611 case 0:
2612 return WifiRateNss::NSS_1x1;
2613 case 1:
2614 return WifiRateNss::NSS_2x2;
2615 case 2:
2616 return WifiRateNss::NSS_3x3;
2617 case 3:
2618 return WifiRateNss::NSS_4x4;
2619 };
2620 CHECK(false) << "Unknown legacy nss: " << nss;
2621 return {};
Roshan Pius3fae9c82016-12-02 14:49:41 -08002622}
2623
2624RttStatus convertLegacyRttStatusToHidl(legacy_hal::wifi_rtt_status status) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002625 switch (status) {
2626 case legacy_hal::RTT_STATUS_SUCCESS:
2627 return RttStatus::SUCCESS;
2628 case legacy_hal::RTT_STATUS_FAILURE:
2629 return RttStatus::FAILURE;
2630 case legacy_hal::RTT_STATUS_FAIL_NO_RSP:
2631 return RttStatus::FAIL_NO_RSP;
2632 case legacy_hal::RTT_STATUS_FAIL_REJECTED:
2633 return RttStatus::FAIL_REJECTED;
2634 case legacy_hal::RTT_STATUS_FAIL_NOT_SCHEDULED_YET:
2635 return RttStatus::FAIL_NOT_SCHEDULED_YET;
2636 case legacy_hal::RTT_STATUS_FAIL_TM_TIMEOUT:
2637 return RttStatus::FAIL_TM_TIMEOUT;
2638 case legacy_hal::RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL:
2639 return RttStatus::FAIL_AP_ON_DIFF_CHANNEL;
2640 case legacy_hal::RTT_STATUS_FAIL_NO_CAPABILITY:
2641 return RttStatus::FAIL_NO_CAPABILITY;
2642 case legacy_hal::RTT_STATUS_ABORTED:
2643 return RttStatus::ABORTED;
2644 case legacy_hal::RTT_STATUS_FAIL_INVALID_TS:
2645 return RttStatus::FAIL_INVALID_TS;
2646 case legacy_hal::RTT_STATUS_FAIL_PROTOCOL:
2647 return RttStatus::FAIL_PROTOCOL;
2648 case legacy_hal::RTT_STATUS_FAIL_SCHEDULE:
2649 return RttStatus::FAIL_SCHEDULE;
2650 case legacy_hal::RTT_STATUS_FAIL_BUSY_TRY_LATER:
2651 return RttStatus::FAIL_BUSY_TRY_LATER;
2652 case legacy_hal::RTT_STATUS_INVALID_REQ:
2653 return RttStatus::INVALID_REQ;
2654 case legacy_hal::RTT_STATUS_NO_WIFI:
2655 return RttStatus::NO_WIFI;
2656 case legacy_hal::RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE:
2657 return RttStatus::FAIL_FTM_PARAM_OVERRIDE;
Etan Cohen69c89222018-03-08 13:39:19 -08002658 case legacy_hal::RTT_STATUS_NAN_RANGING_PROTOCOL_FAILURE:
2659 return RttStatus::FAILURE; // TODO: add HIDL enumeration
2660 case legacy_hal::RTT_STATUS_NAN_RANGING_CONCURRENCY_NOT_SUPPORTED:
2661 return RttStatus::FAILURE; // TODO: add HIDL enumeration
Roshan Piusabcf78f2017-10-06 16:30:38 -07002662 };
2663 CHECK(false) << "Unknown legacy status: " << status;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002664}
2665
2666bool convertHidlWifiChannelInfoToLegacy(
2667 const WifiChannelInfo& hidl_info,
2668 legacy_hal::wifi_channel_info* legacy_info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002669 if (!legacy_info) {
2670 return false;
2671 }
2672 *legacy_info = {};
2673 legacy_info->width = convertHidlWifiChannelWidthToLegacy(hidl_info.width);
2674 legacy_info->center_freq = hidl_info.centerFreq;
2675 legacy_info->center_freq0 = hidl_info.centerFreq0;
2676 legacy_info->center_freq1 = hidl_info.centerFreq1;
2677 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002678}
2679
2680bool convertLegacyWifiChannelInfoToHidl(
2681 const legacy_hal::wifi_channel_info& legacy_info,
2682 WifiChannelInfo* hidl_info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002683 if (!hidl_info) {
2684 return false;
2685 }
2686 *hidl_info = {};
2687 hidl_info->width = convertLegacyWifiChannelWidthToHidl(legacy_info.width);
2688 hidl_info->centerFreq = legacy_info.center_freq;
2689 hidl_info->centerFreq0 = legacy_info.center_freq0;
2690 hidl_info->centerFreq1 = legacy_info.center_freq1;
2691 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002692}
2693
Jimmy Chend460df32019-11-29 17:31:22 +02002694bool convertHidlRttConfigToLegacy(const V1_4::RttConfig& hidl_config,
Roshan Pius3fae9c82016-12-02 14:49:41 -08002695 legacy_hal::wifi_rtt_config* legacy_config) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002696 if (!legacy_config) {
2697 return false;
2698 }
2699 *legacy_config = {};
2700 CHECK(hidl_config.addr.size() == sizeof(legacy_config->addr));
2701 memcpy(legacy_config->addr, hidl_config.addr.data(),
2702 hidl_config.addr.size());
2703 legacy_config->type = convertHidlRttTypeToLegacy(hidl_config.type);
2704 legacy_config->peer = convertHidlRttPeerTypeToLegacy(hidl_config.peer);
2705 if (!convertHidlWifiChannelInfoToLegacy(hidl_config.channel,
2706 &legacy_config->channel)) {
2707 return false;
2708 }
2709 legacy_config->burst_period = hidl_config.burstPeriod;
2710 legacy_config->num_burst = hidl_config.numBurst;
2711 legacy_config->num_frames_per_burst = hidl_config.numFramesPerBurst;
2712 legacy_config->num_retries_per_rtt_frame =
2713 hidl_config.numRetriesPerRttFrame;
2714 legacy_config->num_retries_per_ftmr = hidl_config.numRetriesPerFtmr;
2715 legacy_config->LCI_request = hidl_config.mustRequestLci;
2716 legacy_config->LCR_request = hidl_config.mustRequestLcr;
2717 legacy_config->burst_duration = hidl_config.burstDuration;
2718 legacy_config->preamble =
2719 convertHidlRttPreambleToLegacy(hidl_config.preamble);
2720 legacy_config->bw = convertHidlRttBwToLegacy(hidl_config.bw);
2721 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002722}
2723
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002724bool convertHidlVectorOfRttConfigToLegacy(
Jimmy Chend460df32019-11-29 17:31:22 +02002725 const std::vector<V1_4::RttConfig>& hidl_configs,
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002726 std::vector<legacy_hal::wifi_rtt_config>* legacy_configs) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002727 if (!legacy_configs) {
2728 return false;
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002729 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002730 *legacy_configs = {};
2731 for (const auto& hidl_config : hidl_configs) {
2732 legacy_hal::wifi_rtt_config legacy_config;
2733 if (!convertHidlRttConfigToLegacy(hidl_config, &legacy_config)) {
2734 return false;
2735 }
2736 legacy_configs->push_back(legacy_config);
2737 }
2738 return true;
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002739}
2740
Roshan Pius3fae9c82016-12-02 14:49:41 -08002741bool convertHidlRttLciInformationToLegacy(
2742 const RttLciInformation& hidl_info,
2743 legacy_hal::wifi_lci_information* legacy_info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002744 if (!legacy_info) {
2745 return false;
2746 }
2747 *legacy_info = {};
2748 legacy_info->latitude = hidl_info.latitude;
2749 legacy_info->longitude = hidl_info.longitude;
2750 legacy_info->altitude = hidl_info.altitude;
2751 legacy_info->latitude_unc = hidl_info.latitudeUnc;
2752 legacy_info->longitude_unc = hidl_info.longitudeUnc;
2753 legacy_info->altitude_unc = hidl_info.altitudeUnc;
2754 legacy_info->motion_pattern =
2755 convertHidlRttMotionPatternToLegacy(hidl_info.motionPattern);
2756 legacy_info->floor = hidl_info.floor;
2757 legacy_info->height_above_floor = hidl_info.heightAboveFloor;
2758 legacy_info->height_unc = hidl_info.heightUnc;
2759 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002760}
2761
2762bool convertHidlRttLcrInformationToLegacy(
2763 const RttLcrInformation& hidl_info,
2764 legacy_hal::wifi_lcr_information* legacy_info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002765 if (!legacy_info) {
2766 return false;
2767 }
2768 *legacy_info = {};
2769 CHECK(hidl_info.countryCode.size() == sizeof(legacy_info->country_code));
2770 memcpy(legacy_info->country_code, hidl_info.countryCode.data(),
2771 hidl_info.countryCode.size());
2772 if (hidl_info.civicInfo.size() > sizeof(legacy_info->civic_info)) {
2773 return false;
2774 }
2775 legacy_info->length = hidl_info.civicInfo.size();
2776 memcpy(legacy_info->civic_info, hidl_info.civicInfo.c_str(),
2777 hidl_info.civicInfo.size());
2778 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002779}
2780
2781bool convertHidlRttResponderToLegacy(
Jimmy Chend460df32019-11-29 17:31:22 +02002782 const V1_4::RttResponder& hidl_responder,
Roshan Pius3fae9c82016-12-02 14:49:41 -08002783 legacy_hal::wifi_rtt_responder* legacy_responder) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002784 if (!legacy_responder) {
2785 return false;
2786 }
2787 *legacy_responder = {};
2788 if (!convertHidlWifiChannelInfoToLegacy(hidl_responder.channel,
2789 &legacy_responder->channel)) {
2790 return false;
2791 }
2792 legacy_responder->preamble =
2793 convertHidlRttPreambleToLegacy(hidl_responder.preamble);
2794 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002795}
2796
2797bool convertLegacyRttResponderToHidl(
2798 const legacy_hal::wifi_rtt_responder& legacy_responder,
Jimmy Chend460df32019-11-29 17:31:22 +02002799 V1_4::RttResponder* hidl_responder) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002800 if (!hidl_responder) {
2801 return false;
2802 }
2803 *hidl_responder = {};
2804 if (!convertLegacyWifiChannelInfoToHidl(legacy_responder.channel,
2805 &hidl_responder->channel)) {
2806 return false;
2807 }
2808 hidl_responder->preamble =
2809 convertLegacyRttPreambleToHidl(legacy_responder.preamble);
2810 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002811}
2812
2813bool convertLegacyRttCapabilitiesToHidl(
2814 const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
Jimmy Chend460df32019-11-29 17:31:22 +02002815 V1_4::RttCapabilities* hidl_capabilities) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002816 if (!hidl_capabilities) {
2817 return false;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002818 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002819 *hidl_capabilities = {};
2820 hidl_capabilities->rttOneSidedSupported =
2821 legacy_capabilities.rtt_one_sided_supported;
2822 hidl_capabilities->rttFtmSupported = legacy_capabilities.rtt_ftm_supported;
2823 hidl_capabilities->lciSupported = legacy_capabilities.lci_support;
2824 hidl_capabilities->lcrSupported = legacy_capabilities.lcr_support;
2825 hidl_capabilities->responderSupported =
2826 legacy_capabilities.responder_supported;
2827 hidl_capabilities->preambleSupport = 0;
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07002828 for (const auto flag :
2829 {legacy_hal::WIFI_RTT_PREAMBLE_LEGACY,
2830 legacy_hal::WIFI_RTT_PREAMBLE_HT, legacy_hal::WIFI_RTT_PREAMBLE_VHT,
2831 legacy_hal::WIFI_RTT_PREAMBLE_HE}) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002832 if (legacy_capabilities.preamble_support & flag) {
2833 hidl_capabilities->preambleSupport |=
Jimmy Chend460df32019-11-29 17:31:22 +02002834 static_cast<std::underlying_type<V1_4::RttPreamble>::type>(
Roshan Piusabcf78f2017-10-06 16:30:38 -07002835 convertLegacyRttPreambleToHidl(flag));
2836 }
Roshan Pius3fae9c82016-12-02 14:49:41 -08002837 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002838 hidl_capabilities->bwSupport = 0;
2839 for (const auto flag :
2840 {legacy_hal::WIFI_RTT_BW_5, legacy_hal::WIFI_RTT_BW_10,
2841 legacy_hal::WIFI_RTT_BW_20, legacy_hal::WIFI_RTT_BW_40,
2842 legacy_hal::WIFI_RTT_BW_80, legacy_hal::WIFI_RTT_BW_160}) {
2843 if (legacy_capabilities.bw_support & flag) {
2844 hidl_capabilities->bwSupport |=
2845 static_cast<std::underlying_type<RttBw>::type>(
2846 convertLegacyRttBwToHidl(flag));
2847 }
2848 }
2849 hidl_capabilities->mcVersion = legacy_capabilities.mc_version;
2850 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002851}
2852
2853bool convertLegacyWifiRateInfoToHidl(const legacy_hal::wifi_rate& legacy_rate,
Jimmy Chend460df32019-11-29 17:31:22 +02002854 V1_4::WifiRateInfo* hidl_rate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002855 if (!hidl_rate) {
2856 return false;
2857 }
2858 *hidl_rate = {};
2859 hidl_rate->preamble =
2860 convertLegacyWifiRatePreambleToHidl(legacy_rate.preamble);
2861 hidl_rate->nss = convertLegacyWifiRateNssToHidl(legacy_rate.nss);
2862 hidl_rate->bw = convertLegacyWifiChannelWidthToHidl(
2863 static_cast<legacy_hal::wifi_channel_width>(legacy_rate.bw));
2864 hidl_rate->rateMcsIdx = legacy_rate.rateMcsIdx;
2865 hidl_rate->bitRateInKbps = legacy_rate.bitrate;
2866 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002867}
2868
2869bool convertLegacyRttResultToHidl(
Jimmy Chend460df32019-11-29 17:31:22 +02002870 const legacy_hal::wifi_rtt_result& legacy_result,
2871 V1_4::RttResult* hidl_result) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002872 if (!hidl_result) {
2873 return false;
2874 }
2875 *hidl_result = {};
2876 CHECK(sizeof(legacy_result.addr) == hidl_result->addr.size());
2877 memcpy(hidl_result->addr.data(), legacy_result.addr,
2878 sizeof(legacy_result.addr));
2879 hidl_result->burstNum = legacy_result.burst_num;
2880 hidl_result->measurementNumber = legacy_result.measurement_number;
2881 hidl_result->successNumber = legacy_result.success_number;
2882 hidl_result->numberPerBurstPeer = legacy_result.number_per_burst_peer;
2883 hidl_result->status = convertLegacyRttStatusToHidl(legacy_result.status);
2884 hidl_result->retryAfterDuration = legacy_result.retry_after_duration;
2885 hidl_result->type = convertLegacyRttTypeToHidl(legacy_result.type);
2886 hidl_result->rssi = legacy_result.rssi;
2887 hidl_result->rssiSpread = legacy_result.rssi_spread;
2888 if (!convertLegacyWifiRateInfoToHidl(legacy_result.tx_rate,
2889 &hidl_result->txRate)) {
2890 return false;
2891 }
2892 if (!convertLegacyWifiRateInfoToHidl(legacy_result.rx_rate,
2893 &hidl_result->rxRate)) {
2894 return false;
2895 }
2896 hidl_result->rtt = legacy_result.rtt;
2897 hidl_result->rttSd = legacy_result.rtt_sd;
2898 hidl_result->rttSpread = legacy_result.rtt_spread;
2899 hidl_result->distanceInMm = legacy_result.distance_mm;
2900 hidl_result->distanceSdInMm = legacy_result.distance_sd_mm;
2901 hidl_result->distanceSpreadInMm = legacy_result.distance_spread_mm;
2902 hidl_result->timeStampInUs = legacy_result.ts;
2903 hidl_result->burstDurationInMs = legacy_result.burst_duration;
2904 hidl_result->negotiatedBurstNum = legacy_result.negotiated_burst_num;
2905 if (legacy_result.LCI &&
2906 !convertLegacyIeToHidl(*legacy_result.LCI, &hidl_result->lci)) {
2907 return false;
2908 }
2909 if (legacy_result.LCR &&
2910 !convertLegacyIeToHidl(*legacy_result.LCR, &hidl_result->lcr)) {
2911 return false;
2912 }
2913 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002914}
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002915
2916bool convertLegacyVectorOfRttResultToHidl(
2917 const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
Jimmy Chend460df32019-11-29 17:31:22 +02002918 std::vector<V1_4::RttResult>* hidl_results) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002919 if (!hidl_results) {
2920 return false;
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002921 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002922 *hidl_results = {};
2923 for (const auto legacy_result : legacy_results) {
Jimmy Chend460df32019-11-29 17:31:22 +02002924 V1_4::RttResult hidl_result;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002925 if (!convertLegacyRttResultToHidl(*legacy_result, &hidl_result)) {
2926 return false;
2927 }
2928 hidl_results->push_back(hidl_result);
2929 }
2930 return true;
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002931}
Sunil Raviddab4bb2020-02-03 22:45:19 -08002932
2933legacy_hal::wifi_interface_type convertHidlIfaceTypeToLegacy(
2934 IfaceType hidl_interface_type) {
2935 switch (hidl_interface_type) {
2936 case IfaceType::STA:
2937 return legacy_hal::WIFI_INTERFACE_TYPE_STA;
2938 case IfaceType::AP:
2939 return legacy_hal::WIFI_INTERFACE_TYPE_AP;
2940 case IfaceType::P2P:
2941 return legacy_hal::WIFI_INTERFACE_TYPE_P2P;
2942 case IfaceType::NAN:
2943 return legacy_hal::WIFI_INTERFACE_TYPE_NAN;
2944 }
2945 CHECK(false);
2946}
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08002947
2948legacy_hal::wifi_multi_sta_use_case convertHidlMultiStaUseCaseToLegacy(
2949 IWifiChip::MultiStaUseCase use_case) {
2950 switch (use_case) {
2951 case IWifiChip::MultiStaUseCase::DUAL_STA_TRANSIENT_PREFER_PRIMARY:
2952 return legacy_hal::WIFI_DUAL_STA_TRANSIENT_PREFER_PRIMARY;
2953 case IWifiChip::MultiStaUseCase::DUAL_STA_NON_TRANSIENT_UNBIASED:
2954 return legacy_hal::WIFI_DUAL_STA_NON_TRANSIENT_UNBIASED;
2955 }
2956 CHECK(false);
2957}
Quang Luong94bcce52020-11-25 17:52:19 -08002958
2959bool convertHidlCoexUnsafeChannelToLegacy(
2960 const IWifiChip::CoexUnsafeChannel& hidl_unsafe_channel,
2961 legacy_hal::wifi_coex_unsafe_channel* legacy_unsafe_channel) {
2962 if (!legacy_unsafe_channel) {
2963 return false;
2964 }
2965 *legacy_unsafe_channel = {};
2966 switch (hidl_unsafe_channel.band) {
2967 case WifiBand::BAND_24GHZ:
2968 legacy_unsafe_channel->band = legacy_hal::WLAN_MAC_2_4_BAND;
2969 break;
2970 case WifiBand::BAND_5GHZ:
2971 legacy_unsafe_channel->band = legacy_hal::WLAN_MAC_5_0_BAND;
2972 break;
2973 default:
2974 return false;
2975 };
2976 legacy_unsafe_channel->channel = hidl_unsafe_channel.channel;
2977 legacy_unsafe_channel->power_cap_dbm = hidl_unsafe_channel.powerCapDbm;
2978 return true;
2979}
2980
2981bool convertHidlVectorOfCoexUnsafeChannelToLegacy(
2982 const std::vector<IWifiChip::CoexUnsafeChannel>& hidl_unsafe_channels,
2983 std::vector<legacy_hal::wifi_coex_unsafe_channel>* legacy_unsafe_channels) {
2984 if (!legacy_unsafe_channels) {
2985 return false;
2986 }
2987 *legacy_unsafe_channels = {};
2988 for (const auto& hidl_unsafe_channel : hidl_unsafe_channels) {
2989 legacy_hal::wifi_coex_unsafe_channel legacy_unsafe_channel;
2990 if (!hidl_struct_util::convertHidlCoexUnsafeChannelToLegacy(
2991 hidl_unsafe_channel, &legacy_unsafe_channel)) {
2992 return false;
2993 }
2994 legacy_unsafe_channels->push_back(legacy_unsafe_channel);
2995 }
2996 return true;
2997}
2998
Roshan Piuse65edb12016-11-22 13:02:01 -08002999} // namespace hidl_struct_util
3000} // namespace implementation
Jimmy Chend460df32019-11-29 17:31:22 +02003001} // namespace V1_5
Roshan Piuse65edb12016-11-22 13:02:01 -08003002} // namespace wifi
3003} // namespace hardware
3004} // namespace android