blob: 6eeb6422e5cb84a05943cd7f8db397b5d219f5ac [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 {
Ahmed ElArabawyf501a982019-07-23 15:02:22 -070025namespace V1_4 {
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
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -070072V1_3::IWifiChip::ChipCapabilityMask convertLegacyFeatureToHidlChipCapability(
Roshan Pius8184d212017-07-11 08:59:29 -070073 uint32_t feature) {
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -070074 using HidlChipCaps = V1_3::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;
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -070084 case WIFI_FEATURE_SET_LATENCY_MODE:
85 return HidlChipCaps::SET_LATENCY_MODE;
Jimmy Chend87a0ee2018-12-14 15:38:58 +080086 case WIFI_FEATURE_P2P_RAND_MAC:
87 return HidlChipCaps::P2P_RAND_MAC;
Roshan Piusabcf78f2017-10-06 16:30:38 -070088 };
89 CHECK(false) << "Unknown legacy feature: " << feature;
90 return {};
Roshan Pius8184d212017-07-11 08:59:29 -070091}
92
Roshan Piusf72df2e2016-12-04 10:49:38 -080093IWifiStaIface::StaIfaceCapabilityMask
Ahmed ElArabawy95e36b72019-11-15 21:24:53 +000094convertLegacyFeatureToHidlStaIfaceCapability(uint64_t feature) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070095 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
96 switch (feature) {
97 case WIFI_FEATURE_GSCAN:
98 return HidlStaIfaceCaps::BACKGROUND_SCAN;
99 case WIFI_FEATURE_LINK_LAYER_STATS:
100 return HidlStaIfaceCaps::LINK_LAYER_STATS;
101 case WIFI_FEATURE_RSSI_MONITOR:
102 return HidlStaIfaceCaps::RSSI_MONITOR;
103 case WIFI_FEATURE_CONTROL_ROAMING:
104 return HidlStaIfaceCaps::CONTROL_ROAMING;
105 case WIFI_FEATURE_IE_WHITELIST:
106 return HidlStaIfaceCaps::PROBE_IE_WHITELIST;
107 case WIFI_FEATURE_SCAN_RAND:
108 return HidlStaIfaceCaps::SCAN_RAND;
109 case WIFI_FEATURE_INFRA_5G:
110 return HidlStaIfaceCaps::STA_5G;
111 case WIFI_FEATURE_HOTSPOT:
112 return HidlStaIfaceCaps::HOTSPOT;
113 case WIFI_FEATURE_PNO:
114 return HidlStaIfaceCaps::PNO;
115 case WIFI_FEATURE_TDLS:
116 return HidlStaIfaceCaps::TDLS;
117 case WIFI_FEATURE_TDLS_OFFCHANNEL:
118 return HidlStaIfaceCaps::TDLS_OFFCHANNEL;
119 case WIFI_FEATURE_CONFIG_NDO:
120 return HidlStaIfaceCaps::ND_OFFLOAD;
121 case WIFI_FEATURE_MKEEP_ALIVE:
122 return HidlStaIfaceCaps::KEEP_ALIVE;
Ahmed ElArabawy95e36b72019-11-15 21:24:53 +0000123 case WIFI_FEATURE_INFRA_6G:
124 return HidlStaIfaceCaps::STA_6G;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700125 };
126 CHECK(false) << "Unknown legacy feature: " << feature;
127 return {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800128}
129
130bool convertLegacyFeaturesToHidlChipCapabilities(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700131 uint32_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 Chend87a0ee2018-12-14 15:38:58 +0800148 std::vector<uint32_t> features = {WIFI_FEATURE_SET_TX_POWER_LIMIT,
149 WIFI_FEATURE_USE_BODY_HEAD_SAR,
150 WIFI_FEATURE_D2D_RTT,
151 WIFI_FEATURE_D2AP_RTT,
152 WIFI_FEATURE_SET_LATENCY_MODE,
153 WIFI_FEATURE_P2P_RAND_MAC};
154 for (const auto feature : features) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700155 if (feature & legacy_feature_set) {
156 *hidl_caps |= convertLegacyFeatureToHidlChipCapability(feature);
157 }
158 }
Jimmy Chend87a0ee2018-12-14 15:38:58 +0800159
Roshan Piusabcf78f2017-10-06 16:30:38 -0700160 // There are no flags for these 3 in the legacy feature set. Adding them to
161 // the set because all the current devices support it.
162 *hidl_caps |= HidlChipCaps::DEBUG_RING_BUFFER_VENDOR_DATA;
163 *hidl_caps |= HidlChipCaps::DEBUG_HOST_WAKE_REASON_STATS;
164 *hidl_caps |= HidlChipCaps::DEBUG_ERROR_ALERTS;
165 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800166}
167
168WifiDebugRingBufferFlags convertLegacyDebugRingBufferFlagsToHidl(
169 uint32_t flag) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700170 switch (flag) {
171 case WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES:
172 return WifiDebugRingBufferFlags::HAS_BINARY_ENTRIES;
173 case WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES:
174 return WifiDebugRingBufferFlags::HAS_ASCII_ENTRIES;
175 };
176 CHECK(false) << "Unknown legacy flag: " << flag;
177 return {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800178}
179
180bool convertLegacyDebugRingBufferStatusToHidl(
181 const legacy_hal::wifi_ring_buffer_status& legacy_status,
182 WifiDebugRingBufferStatus* hidl_status) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700183 if (!hidl_status) {
184 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800185 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700186 *hidl_status = {};
187 hidl_status->ringName =
188 safeConvertChar(reinterpret_cast<const char*>(legacy_status.name),
189 sizeof(legacy_status.name));
190 hidl_status->flags = 0;
191 for (const auto flag : {WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES,
192 WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES}) {
193 if (flag & legacy_status.flags) {
194 hidl_status->flags |= static_cast<
195 std::underlying_type<WifiDebugRingBufferFlags>::type>(
196 convertLegacyDebugRingBufferFlagsToHidl(flag));
197 }
198 }
199 hidl_status->ringId = legacy_status.ring_id;
200 hidl_status->sizeInBytes = legacy_status.ring_buffer_byte_size;
201 // Calculate free size of the ring the buffer. We don't need to send the
202 // exact read/write pointers that were there in the legacy HAL interface.
203 if (legacy_status.written_bytes >= legacy_status.read_bytes) {
204 hidl_status->freeSizeInBytes =
205 legacy_status.ring_buffer_byte_size -
206 (legacy_status.written_bytes - legacy_status.read_bytes);
207 } else {
208 hidl_status->freeSizeInBytes =
209 legacy_status.read_bytes - legacy_status.written_bytes;
210 }
211 hidl_status->verboseLevel = legacy_status.verbose_level;
212 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800213}
214
215bool convertLegacyVectorOfDebugRingBufferStatusToHidl(
216 const std::vector<legacy_hal::wifi_ring_buffer_status>& legacy_status_vec,
217 std::vector<WifiDebugRingBufferStatus>* hidl_status_vec) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700218 if (!hidl_status_vec) {
219 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800220 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700221 *hidl_status_vec = {};
222 for (const auto& legacy_status : legacy_status_vec) {
223 WifiDebugRingBufferStatus hidl_status;
224 if (!convertLegacyDebugRingBufferStatusToHidl(legacy_status,
225 &hidl_status)) {
226 return false;
227 }
228 hidl_status_vec->push_back(hidl_status);
229 }
230 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800231}
232
233bool convertLegacyWakeReasonStatsToHidl(
234 const legacy_hal::WakeReasonStats& legacy_stats,
235 WifiDebugHostWakeReasonStats* hidl_stats) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700236 if (!hidl_stats) {
237 return false;
238 }
239 *hidl_stats = {};
240 hidl_stats->totalCmdEventWakeCnt =
241 legacy_stats.wake_reason_cnt.total_cmd_event_wake;
242 hidl_stats->cmdEventWakeCntPerType = legacy_stats.cmd_event_wake_cnt;
243 hidl_stats->totalDriverFwLocalWakeCnt =
244 legacy_stats.wake_reason_cnt.total_driver_fw_local_wake;
245 hidl_stats->driverFwLocalWakeCntPerType =
246 legacy_stats.driver_fw_local_wake_cnt;
247 hidl_stats->totalRxPacketWakeCnt =
248 legacy_stats.wake_reason_cnt.total_rx_data_wake;
249 hidl_stats->rxPktWakeDetails.rxUnicastCnt =
250 legacy_stats.wake_reason_cnt.rx_wake_details.rx_unicast_cnt;
251 hidl_stats->rxPktWakeDetails.rxMulticastCnt =
252 legacy_stats.wake_reason_cnt.rx_wake_details.rx_multicast_cnt;
253 hidl_stats->rxPktWakeDetails.rxBroadcastCnt =
254 legacy_stats.wake_reason_cnt.rx_wake_details.rx_broadcast_cnt;
255 hidl_stats->rxMulticastPkWakeDetails.ipv4RxMulticastAddrCnt =
256 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
257 .ipv4_rx_multicast_addr_cnt;
258 hidl_stats->rxMulticastPkWakeDetails.ipv6RxMulticastAddrCnt =
259 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
260 .ipv6_rx_multicast_addr_cnt;
261 hidl_stats->rxMulticastPkWakeDetails.otherRxMulticastAddrCnt =
262 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
263 .other_rx_multicast_addr_cnt;
264 hidl_stats->rxIcmpPkWakeDetails.icmpPkt =
265 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp_pkt;
266 hidl_stats->rxIcmpPkWakeDetails.icmp6Pkt =
267 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_pkt;
268 hidl_stats->rxIcmpPkWakeDetails.icmp6Ra =
269 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ra;
270 hidl_stats->rxIcmpPkWakeDetails.icmp6Na =
271 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_na;
272 hidl_stats->rxIcmpPkWakeDetails.icmp6Ns =
273 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ns;
274 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800275}
276
Roshan Pius735ff432017-07-25 08:48:08 -0700277legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy(
278 V1_1::IWifiChip::TxPowerScenario hidl_scenario) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700279 switch (hidl_scenario) {
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800280 // This is the only supported scenario for V1_1
Jong Wook Kimda830c92018-07-23 15:29:38 -0700281 case V1_1::IWifiChip::TxPowerScenario::VOICE_CALL:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700282 return legacy_hal::WIFI_POWER_SCENARIO_VOICE_CALL;
283 };
284 CHECK(false);
Roshan Pius735ff432017-07-25 08:48:08 -0700285}
286
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800287legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy_1_2(
Jong Wook Kimda830c92018-07-23 15:29:38 -0700288 V1_2::IWifiChip::TxPowerScenario hidl_scenario) {
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800289 switch (hidl_scenario) {
290 // This is the only supported scenario for V1_1
Jong Wook Kimda830c92018-07-23 15:29:38 -0700291 case V1_2::IWifiChip::TxPowerScenario::VOICE_CALL:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800292 return legacy_hal::WIFI_POWER_SCENARIO_VOICE_CALL;
293 // Those are the supported scenarios for V1_2
Jong Wook Kimda830c92018-07-23 15:29:38 -0700294 case V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800295 return legacy_hal::WIFI_POWER_SCENARIO_ON_HEAD_CELL_OFF;
Jong Wook Kimda830c92018-07-23 15:29:38 -0700296 case V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_ON:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800297 return legacy_hal::WIFI_POWER_SCENARIO_ON_HEAD_CELL_ON;
Jong Wook Kimda830c92018-07-23 15:29:38 -0700298 case V1_2::IWifiChip::TxPowerScenario::ON_BODY_CELL_OFF:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800299 return legacy_hal::WIFI_POWER_SCENARIO_ON_BODY_CELL_OFF;
Jong Wook Kimda830c92018-07-23 15:29:38 -0700300 case V1_2::IWifiChip::TxPowerScenario::ON_BODY_CELL_ON:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800301 return legacy_hal::WIFI_POWER_SCENARIO_ON_BODY_CELL_ON;
302 };
303 CHECK(false);
304}
305
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700306legacy_hal::wifi_latency_mode convertHidlLatencyModeToLegacy(
Ahmed ElArabawyf501a982019-07-23 15:02:22 -0700307 V1_3::IWifiChip::LatencyMode hidl_latency_mode) {
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700308 switch (hidl_latency_mode) {
Ahmed ElArabawyf501a982019-07-23 15:02:22 -0700309 case V1_3::IWifiChip::LatencyMode::NORMAL:
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700310 return legacy_hal::WIFI_LATENCY_MODE_NORMAL;
Ahmed ElArabawyf501a982019-07-23 15:02:22 -0700311 case V1_3::IWifiChip::LatencyMode::LOW:
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700312 return legacy_hal::WIFI_LATENCY_MODE_LOW;
313 }
314 CHECK(false);
315}
316
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800317bool convertLegacyWifiMacInfoToHidl(
318 const legacy_hal::WifiMacInfo& legacy_mac_info,
Jong Wook Kimda830c92018-07-23 15:29:38 -0700319 V1_2::IWifiChipEventCallback::RadioModeInfo* hidl_radio_mode_info) {
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800320 if (!hidl_radio_mode_info) {
321 return false;
322 }
323 *hidl_radio_mode_info = {};
324
325 hidl_radio_mode_info->radioId = legacy_mac_info.wlan_mac_id;
326 // Convert from bitmask of bands in the legacy HAL to enum value in
327 // the HIDL interface.
328 if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND &&
329 legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
330 hidl_radio_mode_info->bandInfo = WifiBand::BAND_24GHZ_5GHZ;
331 } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND) {
332 hidl_radio_mode_info->bandInfo = WifiBand::BAND_24GHZ;
333 } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
334 hidl_radio_mode_info->bandInfo = WifiBand::BAND_5GHZ;
335 } else {
336 hidl_radio_mode_info->bandInfo = WifiBand::BAND_UNSPECIFIED;
337 }
Jong Wook Kimda830c92018-07-23 15:29:38 -0700338 std::vector<V1_2::IWifiChipEventCallback::IfaceInfo> iface_info_vec;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800339 for (const auto& legacy_iface_info : legacy_mac_info.iface_infos) {
Jong Wook Kimda830c92018-07-23 15:29:38 -0700340 V1_2::IWifiChipEventCallback::IfaceInfo iface_info;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800341 iface_info.name = legacy_iface_info.name;
342 iface_info.channel = legacy_iface_info.channel;
343 iface_info_vec.push_back(iface_info);
344 }
345 hidl_radio_mode_info->ifaceInfos = iface_info_vec;
346 return true;
347}
348
349bool convertLegacyWifiMacInfosToHidl(
350 const std::vector<legacy_hal::WifiMacInfo>& legacy_mac_infos,
Jong Wook Kimda830c92018-07-23 15:29:38 -0700351 std::vector<V1_2::IWifiChipEventCallback::RadioModeInfo>*
352 hidl_radio_mode_infos) {
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800353 if (!hidl_radio_mode_infos) {
354 return false;
355 }
356 *hidl_radio_mode_infos = {};
357
358 for (const auto& legacy_mac_info : legacy_mac_infos) {
Jong Wook Kimda830c92018-07-23 15:29:38 -0700359 V1_2::IWifiChipEventCallback::RadioModeInfo hidl_radio_mode_info;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800360 if (!convertLegacyWifiMacInfoToHidl(legacy_mac_info,
361 &hidl_radio_mode_info)) {
362 return false;
363 }
364 hidl_radio_mode_infos->push_back(hidl_radio_mode_info);
365 }
366 return true;
367}
368
Roshan Piusf72df2e2016-12-04 10:49:38 -0800369bool convertLegacyFeaturesToHidlStaCapabilities(
Ahmed ElArabawy95e36b72019-11-15 21:24:53 +0000370 uint64_t legacy_feature_set, uint32_t legacy_logger_feature_set,
Roshan Piusf72df2e2016-12-04 10:49:38 -0800371 uint32_t* hidl_caps) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700372 if (!hidl_caps) {
373 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800374 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700375 *hidl_caps = {};
376 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
377 for (const auto feature : {legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED}) {
378 if (feature & legacy_logger_feature_set) {
379 *hidl_caps |=
380 convertLegacyLoggerFeatureToHidlStaIfaceCapability(feature);
381 }
Roshan Piusf72df2e2016-12-04 10:49:38 -0800382 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700383 for (const auto feature :
384 {WIFI_FEATURE_GSCAN, WIFI_FEATURE_LINK_LAYER_STATS,
385 WIFI_FEATURE_RSSI_MONITOR, WIFI_FEATURE_CONTROL_ROAMING,
386 WIFI_FEATURE_IE_WHITELIST, WIFI_FEATURE_SCAN_RAND,
387 WIFI_FEATURE_INFRA_5G, WIFI_FEATURE_HOTSPOT, WIFI_FEATURE_PNO,
388 WIFI_FEATURE_TDLS, WIFI_FEATURE_TDLS_OFFCHANNEL,
Ahmed ElArabawy95e36b72019-11-15 21:24:53 +0000389 WIFI_FEATURE_CONFIG_NDO, WIFI_FEATURE_MKEEP_ALIVE,
390 WIFI_FEATURE_INFRA_6G}) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700391 if (feature & legacy_feature_set) {
392 *hidl_caps |= convertLegacyFeatureToHidlStaIfaceCapability(feature);
393 }
394 }
395 // There is no flag for this one in the legacy feature set. Adding it to the
396 // set because all the current devices support it.
397 *hidl_caps |= HidlStaIfaceCaps::APF;
398 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800399}
400
401bool convertLegacyApfCapabilitiesToHidl(
402 const legacy_hal::PacketFilterCapabilities& legacy_caps,
403 StaApfPacketFilterCapabilities* hidl_caps) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700404 if (!hidl_caps) {
405 return false;
406 }
407 *hidl_caps = {};
408 hidl_caps->version = legacy_caps.version;
409 hidl_caps->maxLength = legacy_caps.max_len;
410 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800411}
412
Roshan Pius881d1f72016-12-05 15:37:00 -0800413uint8_t convertHidlGscanReportEventFlagToLegacy(
414 StaBackgroundScanBucketEventReportSchemeMask hidl_flag) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700415 using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
416 switch (hidl_flag) {
417 case HidlFlag::EACH_SCAN:
418 return REPORT_EVENTS_EACH_SCAN;
419 case HidlFlag::FULL_RESULTS:
420 return REPORT_EVENTS_FULL_RESULTS;
421 case HidlFlag::NO_BATCH:
422 return REPORT_EVENTS_NO_BATCH;
423 };
424 CHECK(false);
Roshan Pius881d1f72016-12-05 15:37:00 -0800425}
426
427StaScanDataFlagMask convertLegacyGscanDataFlagToHidl(uint8_t legacy_flag) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700428 switch (legacy_flag) {
429 case legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED:
430 return StaScanDataFlagMask::INTERRUPTED;
431 };
432 CHECK(false) << "Unknown legacy flag: " << legacy_flag;
433 // To silence the compiler warning about reaching the end of non-void
434 // function.
435 return {};
Roshan Pius881d1f72016-12-05 15:37:00 -0800436}
437
438bool convertLegacyGscanCapabilitiesToHidl(
Roshan Piusf72df2e2016-12-04 10:49:38 -0800439 const legacy_hal::wifi_gscan_capabilities& legacy_caps,
440 StaBackgroundScanCapabilities* hidl_caps) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700441 if (!hidl_caps) {
442 return false;
443 }
444 *hidl_caps = {};
445 hidl_caps->maxCacheSize = legacy_caps.max_scan_cache_size;
446 hidl_caps->maxBuckets = legacy_caps.max_scan_buckets;
447 hidl_caps->maxApCachePerScan = legacy_caps.max_ap_cache_per_scan;
448 hidl_caps->maxReportingThreshold = legacy_caps.max_scan_reporting_threshold;
449 return true;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800450}
451
Roshan Pius7f4574d2017-02-22 09:48:03 -0800452legacy_hal::wifi_band convertHidlWifiBandToLegacy(WifiBand band) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700453 switch (band) {
454 case WifiBand::BAND_UNSPECIFIED:
455 return legacy_hal::WIFI_BAND_UNSPECIFIED;
456 case WifiBand::BAND_24GHZ:
457 return legacy_hal::WIFI_BAND_BG;
458 case WifiBand::BAND_5GHZ:
459 return legacy_hal::WIFI_BAND_A;
460 case WifiBand::BAND_5GHZ_DFS:
461 return legacy_hal::WIFI_BAND_A_DFS;
462 case WifiBand::BAND_5GHZ_WITH_DFS:
463 return legacy_hal::WIFI_BAND_A_WITH_DFS;
464 case WifiBand::BAND_24GHZ_5GHZ:
465 return legacy_hal::WIFI_BAND_ABG;
466 case WifiBand::BAND_24GHZ_5GHZ_WITH_DFS:
467 return legacy_hal::WIFI_BAND_ABG_WITH_DFS;
468 };
469 CHECK(false);
Roshan Pius881d1f72016-12-05 15:37:00 -0800470}
471
472bool convertHidlGscanParamsToLegacy(
Roshan Piuse65edb12016-11-22 13:02:01 -0800473 const StaBackgroundScanParameters& hidl_scan_params,
474 legacy_hal::wifi_scan_cmd_params* legacy_scan_params) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700475 if (!legacy_scan_params) {
476 return false;
Roshan Pius4cf40592017-03-07 11:17:08 -0800477 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700478 *legacy_scan_params = {};
479 legacy_scan_params->base_period = hidl_scan_params.basePeriodInMs;
480 legacy_scan_params->max_ap_per_scan = hidl_scan_params.maxApPerScan;
481 legacy_scan_params->report_threshold_percent =
482 hidl_scan_params.reportThresholdPercent;
483 legacy_scan_params->report_threshold_num_scans =
484 hidl_scan_params.reportThresholdNumScans;
485 if (hidl_scan_params.buckets.size() > MAX_BUCKETS) {
486 return false;
Roshan Piuse65edb12016-11-22 13:02:01 -0800487 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700488 legacy_scan_params->num_buckets = hidl_scan_params.buckets.size();
489 for (uint32_t bucket_idx = 0; bucket_idx < hidl_scan_params.buckets.size();
490 bucket_idx++) {
491 const StaBackgroundScanBucketParameters& hidl_bucket_spec =
492 hidl_scan_params.buckets[bucket_idx];
493 legacy_hal::wifi_scan_bucket_spec& legacy_bucket_spec =
494 legacy_scan_params->buckets[bucket_idx];
495 if (hidl_bucket_spec.bucketIdx >= MAX_BUCKETS) {
496 return false;
497 }
498 legacy_bucket_spec.bucket = hidl_bucket_spec.bucketIdx;
499 legacy_bucket_spec.band =
500 convertHidlWifiBandToLegacy(hidl_bucket_spec.band);
501 legacy_bucket_spec.period = hidl_bucket_spec.periodInMs;
502 legacy_bucket_spec.max_period =
503 hidl_bucket_spec.exponentialMaxPeriodInMs;
504 legacy_bucket_spec.base = hidl_bucket_spec.exponentialBase;
505 legacy_bucket_spec.step_count = hidl_bucket_spec.exponentialStepCount;
506 legacy_bucket_spec.report_events = 0;
507 using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
508 for (const auto flag : {HidlFlag::EACH_SCAN, HidlFlag::FULL_RESULTS,
509 HidlFlag::NO_BATCH}) {
510 if (hidl_bucket_spec.eventReportScheme &
511 static_cast<std::underlying_type<HidlFlag>::type>(flag)) {
512 legacy_bucket_spec.report_events |=
513 convertHidlGscanReportEventFlagToLegacy(flag);
514 }
515 }
516 if (hidl_bucket_spec.frequencies.size() > MAX_CHANNELS) {
517 return false;
518 }
519 legacy_bucket_spec.num_channels = hidl_bucket_spec.frequencies.size();
520 for (uint32_t freq_idx = 0;
521 freq_idx < hidl_bucket_spec.frequencies.size(); freq_idx++) {
522 legacy_bucket_spec.channels[freq_idx].channel =
523 hidl_bucket_spec.frequencies[freq_idx];
524 }
Roshan Piuse65edb12016-11-22 13:02:01 -0800525 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700526 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800527}
528
Roshan Pius3fae9c82016-12-02 14:49:41 -0800529bool convertLegacyIeToHidl(
530 const legacy_hal::wifi_information_element& legacy_ie,
531 WifiInformationElement* hidl_ie) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700532 if (!hidl_ie) {
533 return false;
534 }
535 *hidl_ie = {};
536 hidl_ie->id = legacy_ie.id;
537 hidl_ie->data =
538 std::vector<uint8_t>(legacy_ie.data, legacy_ie.data + legacy_ie.len);
539 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -0800540}
541
Roshan Piusabcf78f2017-10-06 16:30:38 -0700542bool convertLegacyIeBlobToHidl(const uint8_t* ie_blob, uint32_t ie_blob_len,
Roshan Piuse65edb12016-11-22 13:02:01 -0800543 std::vector<WifiInformationElement>* hidl_ies) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700544 if (!ie_blob || !hidl_ies) {
545 return false;
Roshan Piuse65edb12016-11-22 13:02:01 -0800546 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700547 *hidl_ies = {};
548 const uint8_t* ies_begin = ie_blob;
549 const uint8_t* ies_end = ie_blob + ie_blob_len;
550 const uint8_t* next_ie = ies_begin;
551 using wifi_ie = legacy_hal::wifi_information_element;
552 constexpr size_t kIeHeaderLen = sizeof(wifi_ie);
553 // Each IE should atleast have the header (i.e |id| & |len| fields).
554 while (next_ie + kIeHeaderLen <= ies_end) {
555 const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie));
556 uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len;
557 if (next_ie + curr_ie_len > ies_end) {
558 LOG(ERROR) << "Error parsing IE blob. Next IE: " << (void*)next_ie
559 << ", Curr IE len: " << curr_ie_len
560 << ", IEs End: " << (void*)ies_end;
561 break;
562 }
563 WifiInformationElement hidl_ie;
564 if (!convertLegacyIeToHidl(legacy_ie, &hidl_ie)) {
565 LOG(ERROR) << "Error converting IE. Id: " << legacy_ie.id
566 << ", len: " << legacy_ie.len;
567 break;
568 }
569 hidl_ies->push_back(std::move(hidl_ie));
570 next_ie += curr_ie_len;
Roshan Pius3fae9c82016-12-02 14:49:41 -0800571 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700572 // Check if the blob has been fully consumed.
573 if (next_ie != ies_end) {
574 LOG(ERROR) << "Failed to fully parse IE blob. Next IE: "
575 << (void*)next_ie << ", IEs End: " << (void*)ies_end;
576 }
577 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800578}
579
Roshan Pius881d1f72016-12-05 15:37:00 -0800580bool convertLegacyGscanResultToHidl(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700581 const legacy_hal::wifi_scan_result& legacy_scan_result, bool has_ie_data,
Roshan Piuse65edb12016-11-22 13:02:01 -0800582 StaScanResult* hidl_scan_result) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700583 if (!hidl_scan_result) {
584 return false;
Roshan Piuse65edb12016-11-22 13:02:01 -0800585 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700586 *hidl_scan_result = {};
587 hidl_scan_result->timeStampInUs = legacy_scan_result.ts;
588 hidl_scan_result->ssid = std::vector<uint8_t>(
589 legacy_scan_result.ssid,
590 legacy_scan_result.ssid + strnlen(legacy_scan_result.ssid,
591 sizeof(legacy_scan_result.ssid) - 1));
592 memcpy(hidl_scan_result->bssid.data(), legacy_scan_result.bssid,
593 hidl_scan_result->bssid.size());
594 hidl_scan_result->frequency = legacy_scan_result.channel;
595 hidl_scan_result->rssi = legacy_scan_result.rssi;
596 hidl_scan_result->beaconPeriodInMs = legacy_scan_result.beacon_period;
597 hidl_scan_result->capability = legacy_scan_result.capability;
598 if (has_ie_data) {
599 std::vector<WifiInformationElement> ies;
600 if (!convertLegacyIeBlobToHidl(
601 reinterpret_cast<const uint8_t*>(legacy_scan_result.ie_data),
602 legacy_scan_result.ie_length, &ies)) {
603 return false;
604 }
605 hidl_scan_result->informationElements = std::move(ies);
606 }
607 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800608}
609
Roshan Pius881d1f72016-12-05 15:37:00 -0800610bool convertLegacyCachedGscanResultsToHidl(
Roshan Piuse65edb12016-11-22 13:02:01 -0800611 const legacy_hal::wifi_cached_scan_results& legacy_cached_scan_result,
612 StaScanData* hidl_scan_data) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700613 if (!hidl_scan_data) {
614 return false;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800615 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700616 *hidl_scan_data = {};
617 hidl_scan_data->flags = 0;
618 for (const auto flag : {legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED}) {
619 if (legacy_cached_scan_result.flags & flag) {
620 hidl_scan_data->flags |=
621 static_cast<std::underlying_type<StaScanDataFlagMask>::type>(
622 convertLegacyGscanDataFlagToHidl(flag));
623 }
624 }
625 hidl_scan_data->bucketsScanned = legacy_cached_scan_result.buckets_scanned;
Roshan Piuse65edb12016-11-22 13:02:01 -0800626
Roshan Piusabcf78f2017-10-06 16:30:38 -0700627 CHECK(legacy_cached_scan_result.num_results >= 0 &&
628 legacy_cached_scan_result.num_results <= MAX_AP_CACHE_PER_SCAN);
629 std::vector<StaScanResult> hidl_scan_results;
630 for (int32_t result_idx = 0;
631 result_idx < legacy_cached_scan_result.num_results; result_idx++) {
632 StaScanResult hidl_scan_result;
633 if (!convertLegacyGscanResultToHidl(
634 legacy_cached_scan_result.results[result_idx], false,
635 &hidl_scan_result)) {
636 return false;
637 }
638 hidl_scan_results.push_back(hidl_scan_result);
Roshan Piuse65edb12016-11-22 13:02:01 -0800639 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700640 hidl_scan_data->results = std::move(hidl_scan_results);
641 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800642}
643
Roshan Pius881d1f72016-12-05 15:37:00 -0800644bool convertLegacyVectorOfCachedGscanResultsToHidl(
Roshan Piuse65edb12016-11-22 13:02:01 -0800645 const std::vector<legacy_hal::wifi_cached_scan_results>&
646 legacy_cached_scan_results,
647 std::vector<StaScanData>* hidl_scan_datas) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700648 if (!hidl_scan_datas) {
649 return false;
Roshan Piuse65edb12016-11-22 13:02:01 -0800650 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700651 *hidl_scan_datas = {};
652 for (const auto& legacy_cached_scan_result : legacy_cached_scan_results) {
653 StaScanData hidl_scan_data;
654 if (!convertLegacyCachedGscanResultsToHidl(legacy_cached_scan_result,
655 &hidl_scan_data)) {
656 return false;
657 }
658 hidl_scan_datas->push_back(hidl_scan_data);
659 }
660 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800661}
662
Roshan Pius32d0ca92016-12-02 11:21:19 -0800663WifiDebugTxPacketFate convertLegacyDebugTxPacketFateToHidl(
664 legacy_hal::wifi_tx_packet_fate fate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700665 switch (fate) {
666 case legacy_hal::TX_PKT_FATE_ACKED:
667 return WifiDebugTxPacketFate::ACKED;
668 case legacy_hal::TX_PKT_FATE_SENT:
669 return WifiDebugTxPacketFate::SENT;
670 case legacy_hal::TX_PKT_FATE_FW_QUEUED:
671 return WifiDebugTxPacketFate::FW_QUEUED;
672 case legacy_hal::TX_PKT_FATE_FW_DROP_INVALID:
673 return WifiDebugTxPacketFate::FW_DROP_INVALID;
674 case legacy_hal::TX_PKT_FATE_FW_DROP_NOBUFS:
675 return WifiDebugTxPacketFate::FW_DROP_NOBUFS;
676 case legacy_hal::TX_PKT_FATE_FW_DROP_OTHER:
677 return WifiDebugTxPacketFate::FW_DROP_OTHER;
678 case legacy_hal::TX_PKT_FATE_DRV_QUEUED:
679 return WifiDebugTxPacketFate::DRV_QUEUED;
680 case legacy_hal::TX_PKT_FATE_DRV_DROP_INVALID:
681 return WifiDebugTxPacketFate::DRV_DROP_INVALID;
682 case legacy_hal::TX_PKT_FATE_DRV_DROP_NOBUFS:
683 return WifiDebugTxPacketFate::DRV_DROP_NOBUFS;
684 case legacy_hal::TX_PKT_FATE_DRV_DROP_OTHER:
685 return WifiDebugTxPacketFate::DRV_DROP_OTHER;
686 };
687 CHECK(false) << "Unknown legacy fate type: " << fate;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800688}
689
690WifiDebugRxPacketFate convertLegacyDebugRxPacketFateToHidl(
691 legacy_hal::wifi_rx_packet_fate fate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700692 switch (fate) {
693 case legacy_hal::RX_PKT_FATE_SUCCESS:
694 return WifiDebugRxPacketFate::SUCCESS;
695 case legacy_hal::RX_PKT_FATE_FW_QUEUED:
696 return WifiDebugRxPacketFate::FW_QUEUED;
697 case legacy_hal::RX_PKT_FATE_FW_DROP_FILTER:
698 return WifiDebugRxPacketFate::FW_DROP_FILTER;
699 case legacy_hal::RX_PKT_FATE_FW_DROP_INVALID:
700 return WifiDebugRxPacketFate::FW_DROP_INVALID;
701 case legacy_hal::RX_PKT_FATE_FW_DROP_NOBUFS:
702 return WifiDebugRxPacketFate::FW_DROP_NOBUFS;
703 case legacy_hal::RX_PKT_FATE_FW_DROP_OTHER:
704 return WifiDebugRxPacketFate::FW_DROP_OTHER;
705 case legacy_hal::RX_PKT_FATE_DRV_QUEUED:
706 return WifiDebugRxPacketFate::DRV_QUEUED;
707 case legacy_hal::RX_PKT_FATE_DRV_DROP_FILTER:
708 return WifiDebugRxPacketFate::DRV_DROP_FILTER;
709 case legacy_hal::RX_PKT_FATE_DRV_DROP_INVALID:
710 return WifiDebugRxPacketFate::DRV_DROP_INVALID;
711 case legacy_hal::RX_PKT_FATE_DRV_DROP_NOBUFS:
712 return WifiDebugRxPacketFate::DRV_DROP_NOBUFS;
713 case legacy_hal::RX_PKT_FATE_DRV_DROP_OTHER:
714 return WifiDebugRxPacketFate::DRV_DROP_OTHER;
715 };
716 CHECK(false) << "Unknown legacy fate type: " << fate;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800717}
718
719WifiDebugPacketFateFrameType convertLegacyDebugPacketFateFrameTypeToHidl(
720 legacy_hal::frame_type type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700721 switch (type) {
722 case legacy_hal::FRAME_TYPE_UNKNOWN:
723 return WifiDebugPacketFateFrameType::UNKNOWN;
724 case legacy_hal::FRAME_TYPE_ETHERNET_II:
725 return WifiDebugPacketFateFrameType::ETHERNET_II;
726 case legacy_hal::FRAME_TYPE_80211_MGMT:
727 return WifiDebugPacketFateFrameType::MGMT_80211;
728 };
729 CHECK(false) << "Unknown legacy frame type: " << type;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800730}
731
732bool convertLegacyDebugPacketFateFrameToHidl(
733 const legacy_hal::frame_info& legacy_frame,
734 WifiDebugPacketFateFrameInfo* hidl_frame) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700735 if (!hidl_frame) {
736 return false;
737 }
738 *hidl_frame = {};
739 hidl_frame->frameType =
740 convertLegacyDebugPacketFateFrameTypeToHidl(legacy_frame.payload_type);
741 hidl_frame->frameLen = legacy_frame.frame_len;
742 hidl_frame->driverTimestampUsec = legacy_frame.driver_timestamp_usec;
743 hidl_frame->firmwareTimestampUsec = legacy_frame.firmware_timestamp_usec;
744 const uint8_t* frame_begin = reinterpret_cast<const uint8_t*>(
745 legacy_frame.frame_content.ethernet_ii_bytes);
746 hidl_frame->frameContent =
747 std::vector<uint8_t>(frame_begin, frame_begin + legacy_frame.frame_len);
748 return true;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800749}
750
751bool convertLegacyDebugTxPacketFateToHidl(
752 const legacy_hal::wifi_tx_report& legacy_fate,
753 WifiDebugTxPacketFateReport* hidl_fate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700754 if (!hidl_fate) {
755 return false;
756 }
757 *hidl_fate = {};
758 hidl_fate->fate = convertLegacyDebugTxPacketFateToHidl(legacy_fate.fate);
759 return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
760 &hidl_fate->frameInfo);
Roshan Pius32d0ca92016-12-02 11:21:19 -0800761}
762
Roshan Piusf72df2e2016-12-04 10:49:38 -0800763bool convertLegacyVectorOfDebugTxPacketFateToHidl(
764 const std::vector<legacy_hal::wifi_tx_report>& legacy_fates,
765 std::vector<WifiDebugTxPacketFateReport>* hidl_fates) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700766 if (!hidl_fates) {
767 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800768 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700769 *hidl_fates = {};
770 for (const auto& legacy_fate : legacy_fates) {
771 WifiDebugTxPacketFateReport hidl_fate;
772 if (!convertLegacyDebugTxPacketFateToHidl(legacy_fate, &hidl_fate)) {
773 return false;
774 }
775 hidl_fates->push_back(hidl_fate);
776 }
777 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800778}
779
Roshan Pius32d0ca92016-12-02 11:21:19 -0800780bool convertLegacyDebugRxPacketFateToHidl(
781 const legacy_hal::wifi_rx_report& legacy_fate,
782 WifiDebugRxPacketFateReport* hidl_fate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700783 if (!hidl_fate) {
784 return false;
785 }
786 *hidl_fate = {};
787 hidl_fate->fate = convertLegacyDebugRxPacketFateToHidl(legacy_fate.fate);
788 return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
789 &hidl_fate->frameInfo);
Roshan Pius32d0ca92016-12-02 11:21:19 -0800790}
791
Roshan Piusf72df2e2016-12-04 10:49:38 -0800792bool convertLegacyVectorOfDebugRxPacketFateToHidl(
793 const std::vector<legacy_hal::wifi_rx_report>& legacy_fates,
794 std::vector<WifiDebugRxPacketFateReport>* hidl_fates) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700795 if (!hidl_fates) {
796 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800797 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700798 *hidl_fates = {};
799 for (const auto& legacy_fate : legacy_fates) {
800 WifiDebugRxPacketFateReport hidl_fate;
801 if (!convertLegacyDebugRxPacketFateToHidl(legacy_fate, &hidl_fate)) {
802 return false;
803 }
804 hidl_fates->push_back(hidl_fate);
805 }
806 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800807}
808
Sunil Ravib0343e72018-11-13 15:52:00 -0800809bool convertLegacyLinkLayerRadioStatsToHidl(
810 const legacy_hal::LinkLayerRadioStats& legacy_radio_stat,
811 V1_3::StaLinkLayerRadioStats* hidl_radio_stat) {
812 if (!hidl_radio_stat) {
813 return false;
814 }
815 *hidl_radio_stat = {};
816
817 hidl_radio_stat->V1_0.onTimeInMs = legacy_radio_stat.stats.on_time;
818 hidl_radio_stat->V1_0.txTimeInMs = legacy_radio_stat.stats.tx_time;
819 hidl_radio_stat->V1_0.rxTimeInMs = legacy_radio_stat.stats.rx_time;
820 hidl_radio_stat->V1_0.onTimeInMsForScan =
821 legacy_radio_stat.stats.on_time_scan;
822 hidl_radio_stat->V1_0.txTimeInMsPerLevel =
823 legacy_radio_stat.tx_time_per_levels;
824 hidl_radio_stat->onTimeInMsForNanScan = legacy_radio_stat.stats.on_time_nbd;
825 hidl_radio_stat->onTimeInMsForBgScan =
826 legacy_radio_stat.stats.on_time_gscan;
827 hidl_radio_stat->onTimeInMsForRoamScan =
828 legacy_radio_stat.stats.on_time_roam_scan;
829 hidl_radio_stat->onTimeInMsForPnoScan =
830 legacy_radio_stat.stats.on_time_pno_scan;
831 hidl_radio_stat->onTimeInMsForHs20Scan =
832 legacy_radio_stat.stats.on_time_hs20;
833
834 std::vector<V1_3::WifiChannelStats> hidl_channel_stats;
835
836 for (const auto& channel_stat : legacy_radio_stat.channel_stats) {
837 V1_3::WifiChannelStats hidl_channel_stat;
838 hidl_channel_stat.onTimeInMs = channel_stat.on_time;
839 hidl_channel_stat.ccaBusyTimeInMs = channel_stat.cca_busy_time;
840 /*
841 * TODO once b/119142899 is fixed,
842 * replace below code with convertLegacyWifiChannelInfoToHidl()
843 */
844 hidl_channel_stat.channel.width = WifiChannelWidthInMhz::WIDTH_20;
845 hidl_channel_stat.channel.centerFreq = channel_stat.channel.center_freq;
846 hidl_channel_stat.channel.centerFreq0 =
847 channel_stat.channel.center_freq0;
848 hidl_channel_stat.channel.centerFreq1 =
849 channel_stat.channel.center_freq1;
850 hidl_channel_stats.push_back(hidl_channel_stat);
851 }
852
853 hidl_radio_stat->channelStats = hidl_channel_stats;
854
855 return true;
856}
857
Roshan Piuse65edb12016-11-22 13:02:01 -0800858bool convertLegacyLinkLayerStatsToHidl(
859 const legacy_hal::LinkLayerStats& legacy_stats,
xshue9873252018-08-07 11:04:34 -0700860 V1_3::StaLinkLayerStats* hidl_stats) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700861 if (!hidl_stats) {
862 return false;
863 }
864 *hidl_stats = {};
865 // iface legacy_stats conversion.
866 hidl_stats->iface.beaconRx = legacy_stats.iface.beacon_rx;
867 hidl_stats->iface.avgRssiMgmt = legacy_stats.iface.rssi_mgmt;
868 hidl_stats->iface.wmeBePktStats.rxMpdu =
869 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu;
870 hidl_stats->iface.wmeBePktStats.txMpdu =
871 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu;
872 hidl_stats->iface.wmeBePktStats.lostMpdu =
873 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost;
874 hidl_stats->iface.wmeBePktStats.retries =
875 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries;
876 hidl_stats->iface.wmeBkPktStats.rxMpdu =
877 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu;
878 hidl_stats->iface.wmeBkPktStats.txMpdu =
879 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu;
880 hidl_stats->iface.wmeBkPktStats.lostMpdu =
881 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost;
882 hidl_stats->iface.wmeBkPktStats.retries =
883 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries;
884 hidl_stats->iface.wmeViPktStats.rxMpdu =
885 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu;
886 hidl_stats->iface.wmeViPktStats.txMpdu =
887 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu;
888 hidl_stats->iface.wmeViPktStats.lostMpdu =
889 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost;
890 hidl_stats->iface.wmeViPktStats.retries =
891 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries;
892 hidl_stats->iface.wmeVoPktStats.rxMpdu =
893 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu;
894 hidl_stats->iface.wmeVoPktStats.txMpdu =
895 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu;
896 hidl_stats->iface.wmeVoPktStats.lostMpdu =
897 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost;
898 hidl_stats->iface.wmeVoPktStats.retries =
899 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries;
900 // radio legacy_stats conversion.
xshue9873252018-08-07 11:04:34 -0700901 std::vector<V1_3::StaLinkLayerRadioStats> hidl_radios_stats;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700902 for (const auto& legacy_radio_stats : legacy_stats.radios) {
xshue9873252018-08-07 11:04:34 -0700903 V1_3::StaLinkLayerRadioStats hidl_radio_stats;
Sunil Ravib0343e72018-11-13 15:52:00 -0800904 if (!convertLegacyLinkLayerRadioStatsToHidl(legacy_radio_stats,
905 &hidl_radio_stats)) {
906 return false;
907 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700908 hidl_radios_stats.push_back(hidl_radio_stats);
909 }
910 hidl_stats->radios = hidl_radios_stats;
911 // Timestamp in the HAL wrapper here since it's not provided in the legacy
912 // HAL API.
913 hidl_stats->timeStampInMs = uptimeMillis();
914 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800915}
Roshan Piusf5f51fd2016-12-01 13:54:24 -0800916
Roshan Pius26801cb2016-12-13 14:25:45 -0800917bool convertLegacyRoamingCapabilitiesToHidl(
918 const legacy_hal::wifi_roaming_capabilities& legacy_caps,
919 StaRoamingCapabilities* hidl_caps) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700920 if (!hidl_caps) {
921 return false;
922 }
923 *hidl_caps = {};
924 hidl_caps->maxBlacklistSize = legacy_caps.max_blacklist_size;
925 hidl_caps->maxWhitelistSize = legacy_caps.max_whitelist_size;
926 return true;
Roshan Pius26801cb2016-12-13 14:25:45 -0800927}
928
929bool convertHidlRoamingConfigToLegacy(
930 const StaRoamingConfig& hidl_config,
931 legacy_hal::wifi_roaming_config* legacy_config) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700932 if (!legacy_config) {
933 return false;
934 }
935 *legacy_config = {};
936 if (hidl_config.bssidBlacklist.size() > MAX_BLACKLIST_BSSID ||
937 hidl_config.ssidWhitelist.size() > MAX_WHITELIST_SSID) {
938 return false;
939 }
940 legacy_config->num_blacklist_bssid = hidl_config.bssidBlacklist.size();
941 uint32_t i = 0;
942 for (const auto& bssid : hidl_config.bssidBlacklist) {
943 CHECK(bssid.size() == sizeof(legacy_hal::mac_addr));
944 memcpy(legacy_config->blacklist_bssid[i++], bssid.data(), bssid.size());
945 }
946 legacy_config->num_whitelist_ssid = hidl_config.ssidWhitelist.size();
947 i = 0;
948 for (const auto& ssid : hidl_config.ssidWhitelist) {
949 CHECK(ssid.size() <= sizeof(legacy_hal::ssid_t::ssid_str));
950 legacy_config->whitelist_ssid[i].length = ssid.size();
951 memcpy(legacy_config->whitelist_ssid[i].ssid_str, ssid.data(),
952 ssid.size());
953 i++;
954 }
955 return true;
Roshan Pius26801cb2016-12-13 14:25:45 -0800956}
957
958legacy_hal::fw_roaming_state_t convertHidlRoamingStateToLegacy(
959 StaRoamingState state) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700960 switch (state) {
961 case StaRoamingState::ENABLED:
962 return legacy_hal::ROAMING_ENABLE;
963 case StaRoamingState::DISABLED:
964 return legacy_hal::ROAMING_DISABLE;
965 };
966 CHECK(false);
Roshan Pius26801cb2016-12-13 14:25:45 -0800967}
968
Etan Cohen67d378d2017-04-03 16:10:54 -0700969legacy_hal::NanMatchAlg convertHidlNanMatchAlgToLegacy(NanMatchAlg type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700970 switch (type) {
971 case NanMatchAlg::MATCH_ONCE:
972 return legacy_hal::NAN_MATCH_ALG_MATCH_ONCE;
973 case NanMatchAlg::MATCH_CONTINUOUS:
974 return legacy_hal::NAN_MATCH_ALG_MATCH_CONTINUOUS;
975 case NanMatchAlg::MATCH_NEVER:
976 return legacy_hal::NAN_MATCH_ALG_MATCH_NEVER;
977 }
978 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -0700979}
980
Roshan Piusabcf78f2017-10-06 16:30:38 -0700981legacy_hal::NanPublishType convertHidlNanPublishTypeToLegacy(
982 NanPublishType type) {
983 switch (type) {
984 case NanPublishType::UNSOLICITED:
985 return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED;
986 case NanPublishType::SOLICITED:
987 return legacy_hal::NAN_PUBLISH_TYPE_SOLICITED;
988 case NanPublishType::UNSOLICITED_SOLICITED:
989 return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
990 }
991 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -0700992}
993
994legacy_hal::NanTxType convertHidlNanTxTypeToLegacy(NanTxType type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700995 switch (type) {
996 case NanTxType::BROADCAST:
997 return legacy_hal::NAN_TX_TYPE_BROADCAST;
998 case NanTxType::UNICAST:
999 return legacy_hal::NAN_TX_TYPE_UNICAST;
1000 }
1001 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001002}
1003
Roshan Piusabcf78f2017-10-06 16:30:38 -07001004legacy_hal::NanSubscribeType convertHidlNanSubscribeTypeToLegacy(
1005 NanSubscribeType type) {
1006 switch (type) {
1007 case NanSubscribeType::PASSIVE:
1008 return legacy_hal::NAN_SUBSCRIBE_TYPE_PASSIVE;
1009 case NanSubscribeType::ACTIVE:
1010 return legacy_hal::NAN_SUBSCRIBE_TYPE_ACTIVE;
1011 }
1012 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001013}
1014
1015legacy_hal::NanSRFType convertHidlNanSrfTypeToLegacy(NanSrfType type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001016 switch (type) {
1017 case NanSrfType::BLOOM_FILTER:
1018 return legacy_hal::NAN_SRF_ATTR_BLOOM_FILTER;
1019 case NanSrfType::PARTIAL_MAC_ADDR:
1020 return legacy_hal::NAN_SRF_ATTR_PARTIAL_MAC_ADDR;
1021 }
1022 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001023}
1024
1025legacy_hal::NanDataPathChannelCfg convertHidlNanDataPathChannelCfgToLegacy(
1026 NanDataPathChannelCfg type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001027 switch (type) {
1028 case NanDataPathChannelCfg::CHANNEL_NOT_REQUESTED:
1029 return legacy_hal::NAN_DP_CHANNEL_NOT_REQUESTED;
1030 case NanDataPathChannelCfg::REQUEST_CHANNEL_SETUP:
1031 return legacy_hal::NAN_DP_REQUEST_CHANNEL_SETUP;
1032 case NanDataPathChannelCfg::FORCE_CHANNEL_SETUP:
1033 return legacy_hal::NAN_DP_FORCE_CHANNEL_SETUP;
1034 }
1035 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001036}
1037
Roshan Piusabcf78f2017-10-06 16:30:38 -07001038NanStatusType convertLegacyNanStatusTypeToHidl(legacy_hal::NanStatusType type) {
1039 switch (type) {
1040 case legacy_hal::NAN_STATUS_SUCCESS:
1041 return NanStatusType::SUCCESS;
1042 case legacy_hal::NAN_STATUS_INTERNAL_FAILURE:
1043 return NanStatusType::INTERNAL_FAILURE;
1044 case legacy_hal::NAN_STATUS_PROTOCOL_FAILURE:
1045 return NanStatusType::PROTOCOL_FAILURE;
1046 case legacy_hal::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID:
1047 return NanStatusType::INVALID_SESSION_ID;
1048 case legacy_hal::NAN_STATUS_NO_RESOURCE_AVAILABLE:
1049 return NanStatusType::NO_RESOURCES_AVAILABLE;
1050 case legacy_hal::NAN_STATUS_INVALID_PARAM:
1051 return NanStatusType::INVALID_ARGS;
1052 case legacy_hal::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID:
1053 return NanStatusType::INVALID_PEER_ID;
1054 case legacy_hal::NAN_STATUS_INVALID_NDP_ID:
1055 return NanStatusType::INVALID_NDP_ID;
1056 case legacy_hal::NAN_STATUS_NAN_NOT_ALLOWED:
1057 return NanStatusType::NAN_NOT_ALLOWED;
1058 case legacy_hal::NAN_STATUS_NO_OTA_ACK:
1059 return NanStatusType::NO_OTA_ACK;
1060 case legacy_hal::NAN_STATUS_ALREADY_ENABLED:
1061 return NanStatusType::ALREADY_ENABLED;
1062 case legacy_hal::NAN_STATUS_FOLLOWUP_QUEUE_FULL:
1063 return NanStatusType::FOLLOWUP_TX_QUEUE_FULL;
1064 case legacy_hal::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED:
1065 return NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED;
1066 }
1067 CHECK(false);
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001068}
1069
Roshan Piusabcf78f2017-10-06 16:30:38 -07001070void convertToWifiNanStatus(legacy_hal::NanStatusType type, const char* str,
1071 size_t max_len, WifiNanStatus* wifiNanStatus) {
1072 wifiNanStatus->status = convertLegacyNanStatusTypeToHidl(type);
1073 wifiNanStatus->description = safeConvertChar(str, max_len);
Etan Cohenbbc0f092017-04-26 16:52:34 -07001074}
1075
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001076bool convertHidlNanEnableRequestToLegacy(
1077 const NanEnableRequest& hidl_request,
1078 legacy_hal::NanEnableRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001079 if (!legacy_request) {
1080 LOG(ERROR)
1081 << "convertHidlNanEnableRequestToLegacy: null legacy_request";
1082 return false;
1083 }
1084 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001085
Roshan Piusabcf78f2017-10-06 16:30:38 -07001086 legacy_request->config_2dot4g_support = 1;
1087 legacy_request->support_2dot4g_val =
1088 hidl_request.operateInBand[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1089 legacy_request->config_support_5g = 1;
1090 legacy_request->support_5g_val =
1091 hidl_request.operateInBand[(size_t)NanBandIndex::NAN_BAND_5GHZ];
1092 legacy_request->config_hop_count_limit = 1;
1093 legacy_request->hop_count_limit_val = hidl_request.hopCountMax;
1094 legacy_request->master_pref = hidl_request.configParams.masterPref;
1095 legacy_request->discovery_indication_cfg = 0;
1096 legacy_request->discovery_indication_cfg |=
1097 hidl_request.configParams.disableDiscoveryAddressChangeIndication ? 0x1
1098 : 0x0;
1099 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001100 hidl_request.configParams.disableStartedClusterIndication ? 0x2 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001101 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001102 hidl_request.configParams.disableJoinedClusterIndication ? 0x4 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001103 legacy_request->config_sid_beacon = 1;
1104 if (hidl_request.configParams.numberOfPublishServiceIdsInBeacon > 127) {
1105 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
1106 "numberOfPublishServiceIdsInBeacon > 127";
1107 return false;
1108 }
1109 legacy_request->sid_beacon_val =
1110 (hidl_request.configParams.includePublishServiceIdsInBeacon ? 0x1
1111 : 0x0) |
1112 (hidl_request.configParams.numberOfPublishServiceIdsInBeacon << 1);
1113 legacy_request->config_subscribe_sid_beacon = 1;
1114 if (hidl_request.configParams.numberOfSubscribeServiceIdsInBeacon > 127) {
1115 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
1116 "numberOfSubscribeServiceIdsInBeacon > 127";
1117 return false;
1118 }
1119 legacy_request->subscribe_sid_beacon_val =
1120 (hidl_request.configParams.includeSubscribeServiceIdsInBeacon ? 0x1
1121 : 0x0) |
1122 (hidl_request.configParams.numberOfSubscribeServiceIdsInBeacon << 1);
1123 legacy_request->config_rssi_window_size = 1;
1124 legacy_request->rssi_window_size_val =
1125 hidl_request.configParams.rssiWindowSize;
1126 legacy_request->config_disc_mac_addr_randomization = 1;
1127 legacy_request->disc_mac_addr_rand_interval_sec =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001128 hidl_request.configParams.macAddressRandomizationIntervalSec;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001129 legacy_request->config_2dot4g_rssi_close = 1;
1130 if (hidl_request.configParams.bandSpecificConfig.size() != 2) {
1131 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
1132 "bandSpecificConfig.size() != 2";
1133 return false;
1134 }
1135 legacy_request->rssi_close_2dot4g_val =
1136 hidl_request.configParams
1137 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1138 .rssiClose;
1139 legacy_request->config_2dot4g_rssi_middle = 1;
1140 legacy_request->rssi_middle_2dot4g_val =
1141 hidl_request.configParams
1142 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1143 .rssiMiddle;
1144 legacy_request->config_2dot4g_rssi_proximity = 1;
1145 legacy_request->rssi_proximity_2dot4g_val =
1146 hidl_request.configParams
1147 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1148 .rssiCloseProximity;
1149 legacy_request->config_scan_params = 1;
1150 legacy_request->scan_params_val
1151 .dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
1152 hidl_request.configParams
1153 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1154 .dwellTimeMs;
1155 legacy_request->scan_params_val
1156 .scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
1157 hidl_request.configParams
1158 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1159 .scanPeriodSec;
1160 legacy_request->config_dw.config_2dot4g_dw_band =
1161 hidl_request.configParams
1162 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1163 .validDiscoveryWindowIntervalVal;
1164 legacy_request->config_dw.dw_2dot4g_interval_val =
1165 hidl_request.configParams
1166 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1167 .discoveryWindowIntervalVal;
1168 legacy_request->config_5g_rssi_close = 1;
1169 legacy_request->rssi_close_5g_val =
1170 hidl_request.configParams
1171 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1172 .rssiClose;
1173 legacy_request->config_5g_rssi_middle = 1;
1174 legacy_request->rssi_middle_5g_val =
1175 hidl_request.configParams
1176 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1177 .rssiMiddle;
1178 legacy_request->config_5g_rssi_close_proximity = 1;
1179 legacy_request->rssi_close_proximity_5g_val =
1180 hidl_request.configParams
1181 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1182 .rssiCloseProximity;
1183 legacy_request->scan_params_val
1184 .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1185 hidl_request.configParams
1186 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1187 .dwellTimeMs;
1188 legacy_request->scan_params_val
1189 .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1190 hidl_request.configParams
1191 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1192 .scanPeriodSec;
1193 legacy_request->scan_params_val
1194 .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1195 hidl_request.configParams
1196 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1197 .dwellTimeMs;
1198 legacy_request->scan_params_val
1199 .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1200 hidl_request.configParams
1201 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1202 .scanPeriodSec;
1203 legacy_request->config_dw.config_5g_dw_band =
1204 hidl_request.configParams
1205 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1206 .validDiscoveryWindowIntervalVal;
1207 legacy_request->config_dw.dw_5g_interval_val =
1208 hidl_request.configParams
1209 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1210 .discoveryWindowIntervalVal;
1211 if (hidl_request.debugConfigs.validClusterIdVals) {
1212 legacy_request->cluster_low =
1213 hidl_request.debugConfigs.clusterIdBottomRangeVal;
1214 legacy_request->cluster_high =
1215 hidl_request.debugConfigs.clusterIdTopRangeVal;
1216 } else { // need 'else' since not configurable in legacy HAL
1217 legacy_request->cluster_low = 0x0000;
1218 legacy_request->cluster_high = 0xFFFF;
1219 }
1220 legacy_request->config_intf_addr =
1221 hidl_request.debugConfigs.validIntfAddrVal;
1222 memcpy(legacy_request->intf_addr_val,
1223 hidl_request.debugConfigs.intfAddrVal.data(), 6);
1224 legacy_request->config_oui = hidl_request.debugConfigs.validOuiVal;
1225 legacy_request->oui_val = hidl_request.debugConfigs.ouiVal;
1226 legacy_request->config_random_factor_force =
1227 hidl_request.debugConfigs.validRandomFactorForceVal;
1228 legacy_request->random_factor_force_val =
1229 hidl_request.debugConfigs.randomFactorForceVal;
1230 legacy_request->config_hop_count_force =
1231 hidl_request.debugConfigs.validHopCountForceVal;
1232 legacy_request->hop_count_force_val =
1233 hidl_request.debugConfigs.hopCountForceVal;
1234 legacy_request->config_24g_channel =
1235 hidl_request.debugConfigs.validDiscoveryChannelVal;
1236 legacy_request->channel_24g_val =
1237 hidl_request.debugConfigs
1238 .discoveryChannelMhzVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1239 legacy_request->config_5g_channel =
1240 hidl_request.debugConfigs.validDiscoveryChannelVal;
1241 legacy_request->channel_5g_val =
1242 hidl_request.debugConfigs
1243 .discoveryChannelMhzVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
1244 legacy_request->config_2dot4g_beacons =
1245 hidl_request.debugConfigs.validUseBeaconsInBandVal;
1246 legacy_request->beacon_2dot4g_val =
1247 hidl_request.debugConfigs
1248 .useBeaconsInBandVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1249 legacy_request->config_5g_beacons =
1250 hidl_request.debugConfigs.validUseBeaconsInBandVal;
1251 legacy_request->beacon_5g_val =
1252 hidl_request.debugConfigs
1253 .useBeaconsInBandVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
1254 legacy_request->config_2dot4g_sdf =
1255 hidl_request.debugConfigs.validUseSdfInBandVal;
1256 legacy_request->sdf_2dot4g_val =
1257 hidl_request.debugConfigs
1258 .useSdfInBandVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1259 legacy_request->config_5g_sdf =
1260 hidl_request.debugConfigs.validUseSdfInBandVal;
1261 legacy_request->sdf_5g_val =
1262 hidl_request.debugConfigs
1263 .useSdfInBandVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001264
Roshan Piusabcf78f2017-10-06 16:30:38 -07001265 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001266}
1267
Etan Cohen9e7a4052017-12-21 13:45:26 -08001268bool convertHidlNanEnableRequest_1_2ToLegacy(
1269 const NanEnableRequest& hidl_request1,
Jong Wook Kimda830c92018-07-23 15:29:38 -07001270 const V1_2::NanConfigRequestSupplemental& hidl_request2,
Etan Cohen9e7a4052017-12-21 13:45:26 -08001271 legacy_hal::NanEnableRequest* legacy_request) {
1272 if (!legacy_request) {
1273 LOG(ERROR)
1274 << "convertHidlNanEnableRequest_1_2ToLegacy: null legacy_request";
1275 return false;
1276 }
1277
1278 *legacy_request = {};
1279 if (!convertHidlNanEnableRequestToLegacy(hidl_request1, legacy_request)) {
1280 return false;
1281 }
1282
1283 legacy_request->config_discovery_beacon_int = 1;
1284 legacy_request->discovery_beacon_interval =
1285 hidl_request2.discoveryBeaconIntervalMs;
1286 legacy_request->config_nss = 1;
1287 legacy_request->nss = hidl_request2.numberOfSpatialStreamsInDiscovery;
1288 legacy_request->config_dw_early_termination = 1;
1289 legacy_request->enable_dw_termination =
1290 hidl_request2.enableDiscoveryWindowEarlyTermination;
Etan Cohen4f5bc6c2017-12-28 13:08:08 -08001291 legacy_request->config_enable_ranging = 1;
1292 legacy_request->enable_ranging = hidl_request2.enableRanging;
Etan Cohen9e7a4052017-12-21 13:45:26 -08001293
1294 return true;
1295}
1296
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001297bool convertHidlNanPublishRequestToLegacy(
1298 const NanPublishRequest& hidl_request,
1299 legacy_hal::NanPublishRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001300 if (!legacy_request) {
1301 LOG(ERROR)
1302 << "convertHidlNanPublishRequestToLegacy: null legacy_request";
1303 return false;
1304 }
1305 *legacy_request = {};
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001306
Roshan Piusabcf78f2017-10-06 16:30:38 -07001307 legacy_request->publish_id = hidl_request.baseConfigs.sessionId;
1308 legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
1309 legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
1310 legacy_request->publish_count = hidl_request.baseConfigs.discoveryCount;
1311 legacy_request->service_name_len =
1312 hidl_request.baseConfigs.serviceName.size();
1313 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1314 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: service_name_len "
1315 "too large";
1316 return false;
1317 }
1318 memcpy(legacy_request->service_name,
1319 hidl_request.baseConfigs.serviceName.data(),
1320 legacy_request->service_name_len);
1321 legacy_request->publish_match_indicator = convertHidlNanMatchAlgToLegacy(
1322 hidl_request.baseConfigs.discoveryMatchIndicator);
1323 legacy_request->service_specific_info_len =
1324 hidl_request.baseConfigs.serviceSpecificInfo.size();
1325 if (legacy_request->service_specific_info_len >
1326 NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1327 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1328 "service_specific_info_len too large";
1329 return false;
1330 }
1331 memcpy(legacy_request->service_specific_info,
1332 hidl_request.baseConfigs.serviceSpecificInfo.data(),
1333 legacy_request->service_specific_info_len);
1334 legacy_request->sdea_service_specific_info_len =
Etan Cohena7543a72017-02-17 13:46:19 -08001335 hidl_request.baseConfigs.extendedServiceSpecificInfo.size();
Roshan Piusabcf78f2017-10-06 16:30:38 -07001336 if (legacy_request->sdea_service_specific_info_len >
1337 NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1338 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1339 "sdea_service_specific_info_len too large";
1340 return false;
1341 }
1342 memcpy(legacy_request->sdea_service_specific_info,
1343 hidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
1344 legacy_request->sdea_service_specific_info_len);
1345 legacy_request->rx_match_filter_len =
1346 hidl_request.baseConfigs.rxMatchFilter.size();
1347 if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1348 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1349 "rx_match_filter_len too large";
1350 return false;
1351 }
1352 memcpy(legacy_request->rx_match_filter,
1353 hidl_request.baseConfigs.rxMatchFilter.data(),
1354 legacy_request->rx_match_filter_len);
1355 legacy_request->tx_match_filter_len =
1356 hidl_request.baseConfigs.txMatchFilter.size();
1357 if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1358 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1359 "tx_match_filter_len too large";
1360 return false;
1361 }
1362 memcpy(legacy_request->tx_match_filter,
1363 hidl_request.baseConfigs.txMatchFilter.data(),
1364 legacy_request->tx_match_filter_len);
1365 legacy_request->rssi_threshold_flag =
1366 hidl_request.baseConfigs.useRssiThreshold;
1367 legacy_request->recv_indication_cfg = 0;
1368 legacy_request->recv_indication_cfg |=
1369 hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1
1370 : 0x0;
1371 legacy_request->recv_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001372 hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001373 legacy_request->recv_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001374 hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001375 legacy_request->recv_indication_cfg |= 0x8;
1376 legacy_request->cipher_type =
1377 (unsigned int)hidl_request.baseConfigs.securityConfig.cipherType;
1378 if (hidl_request.baseConfigs.securityConfig.securityType ==
1379 NanDataPathSecurityType::PMK) {
1380 legacy_request->key_info.key_type =
1381 legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1382 legacy_request->key_info.body.pmk_info.pmk_len =
1383 hidl_request.baseConfigs.securityConfig.pmk.size();
1384 if (legacy_request->key_info.body.pmk_info.pmk_len !=
1385 NAN_PMK_INFO_LEN) {
1386 LOG(ERROR)
1387 << "convertHidlNanPublishRequestToLegacy: invalid pmk_len";
1388 return false;
1389 }
1390 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1391 hidl_request.baseConfigs.securityConfig.pmk.data(),
1392 legacy_request->key_info.body.pmk_info.pmk_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001393 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001394 if (hidl_request.baseConfigs.securityConfig.securityType ==
1395 NanDataPathSecurityType::PASSPHRASE) {
1396 legacy_request->key_info.key_type =
1397 legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1398 legacy_request->key_info.body.passphrase_info.passphrase_len =
1399 hidl_request.baseConfigs.securityConfig.passphrase.size();
1400 if (legacy_request->key_info.body.passphrase_info.passphrase_len <
1401 NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1402 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1403 "passphrase_len too small";
1404 return false;
1405 }
1406 if (legacy_request->key_info.body.passphrase_info.passphrase_len >
1407 NAN_SECURITY_MAX_PASSPHRASE_LEN) {
1408 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1409 "passphrase_len too large";
1410 return false;
1411 }
1412 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1413 hidl_request.baseConfigs.securityConfig.passphrase.data(),
1414 legacy_request->key_info.body.passphrase_info.passphrase_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001415 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001416 legacy_request->sdea_params.security_cfg =
1417 (hidl_request.baseConfigs.securityConfig.securityType !=
1418 NanDataPathSecurityType::OPEN)
1419 ? legacy_hal::NAN_DP_CONFIG_SECURITY
Etan Cohenc58619e2017-03-14 14:54:40 -07001420 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001421 legacy_request->sdea_params.ranging_state =
1422 hidl_request.baseConfigs.rangingRequired
1423 ? legacy_hal::NAN_RANGING_ENABLE
1424 : legacy_hal::NAN_RANGING_DISABLE;
1425 legacy_request->ranging_cfg.ranging_interval_msec =
1426 hidl_request.baseConfigs.rangingIntervalMsec;
1427 legacy_request->ranging_cfg.config_ranging_indications =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001428 hidl_request.baseConfigs.configRangingIndications;
Etan Cohen7b8c5d72017-12-14 18:12:04 -08001429 legacy_request->ranging_cfg.distance_ingress_mm =
1430 hidl_request.baseConfigs.distanceIngressCm * 10;
1431 legacy_request->ranging_cfg.distance_egress_mm =
1432 hidl_request.baseConfigs.distanceEgressCm * 10;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001433 legacy_request->ranging_auto_response =
1434 hidl_request.baseConfigs.rangingRequired
1435 ? legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE
1436 : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
1437 legacy_request->sdea_params.range_report =
1438 legacy_hal::NAN_DISABLE_RANGE_REPORT;
1439 legacy_request->publish_type =
1440 convertHidlNanPublishTypeToLegacy(hidl_request.publishType);
1441 legacy_request->tx_type = convertHidlNanTxTypeToLegacy(hidl_request.txType);
1442 legacy_request->service_responder_policy =
1443 hidl_request.autoAcceptDataPathRequests
1444 ? legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL
1445 : legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001446
Roshan Piusabcf78f2017-10-06 16:30:38 -07001447 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001448}
1449
1450bool convertHidlNanSubscribeRequestToLegacy(
1451 const NanSubscribeRequest& hidl_request,
1452 legacy_hal::NanSubscribeRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001453 if (!legacy_request) {
1454 LOG(ERROR)
1455 << "convertHidlNanSubscribeRequestToLegacy: legacy_request is null";
1456 return false;
1457 }
1458 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001459
Roshan Piusabcf78f2017-10-06 16:30:38 -07001460 legacy_request->subscribe_id = hidl_request.baseConfigs.sessionId;
1461 legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
1462 legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
1463 legacy_request->subscribe_count = hidl_request.baseConfigs.discoveryCount;
1464 legacy_request->service_name_len =
1465 hidl_request.baseConfigs.serviceName.size();
1466 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1467 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1468 "service_name_len too large";
1469 return false;
1470 }
1471 memcpy(legacy_request->service_name,
1472 hidl_request.baseConfigs.serviceName.data(),
1473 legacy_request->service_name_len);
1474 legacy_request->subscribe_match_indicator = convertHidlNanMatchAlgToLegacy(
1475 hidl_request.baseConfigs.discoveryMatchIndicator);
1476 legacy_request->service_specific_info_len =
1477 hidl_request.baseConfigs.serviceSpecificInfo.size();
1478 if (legacy_request->service_specific_info_len >
1479 NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1480 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1481 "service_specific_info_len too large";
1482 return false;
1483 }
1484 memcpy(legacy_request->service_specific_info,
1485 hidl_request.baseConfigs.serviceSpecificInfo.data(),
1486 legacy_request->service_specific_info_len);
1487 legacy_request->sdea_service_specific_info_len =
Etan Cohena7543a72017-02-17 13:46:19 -08001488 hidl_request.baseConfigs.extendedServiceSpecificInfo.size();
Roshan Piusabcf78f2017-10-06 16:30:38 -07001489 if (legacy_request->sdea_service_specific_info_len >
1490 NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1491 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1492 "sdea_service_specific_info_len too large";
1493 return false;
1494 }
1495 memcpy(legacy_request->sdea_service_specific_info,
1496 hidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
1497 legacy_request->sdea_service_specific_info_len);
1498 legacy_request->rx_match_filter_len =
1499 hidl_request.baseConfigs.rxMatchFilter.size();
1500 if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1501 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1502 "rx_match_filter_len too large";
1503 return false;
1504 }
1505 memcpy(legacy_request->rx_match_filter,
1506 hidl_request.baseConfigs.rxMatchFilter.data(),
1507 legacy_request->rx_match_filter_len);
1508 legacy_request->tx_match_filter_len =
1509 hidl_request.baseConfigs.txMatchFilter.size();
1510 if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1511 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1512 "tx_match_filter_len too large";
1513 return false;
1514 }
1515 memcpy(legacy_request->tx_match_filter,
1516 hidl_request.baseConfigs.txMatchFilter.data(),
1517 legacy_request->tx_match_filter_len);
1518 legacy_request->rssi_threshold_flag =
1519 hidl_request.baseConfigs.useRssiThreshold;
1520 legacy_request->recv_indication_cfg = 0;
1521 legacy_request->recv_indication_cfg |=
1522 hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1
1523 : 0x0;
1524 legacy_request->recv_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001525 hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001526 legacy_request->recv_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001527 hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001528 legacy_request->cipher_type =
1529 (unsigned int)hidl_request.baseConfigs.securityConfig.cipherType;
1530 if (hidl_request.baseConfigs.securityConfig.securityType ==
1531 NanDataPathSecurityType::PMK) {
1532 legacy_request->key_info.key_type =
1533 legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1534 legacy_request->key_info.body.pmk_info.pmk_len =
1535 hidl_request.baseConfigs.securityConfig.pmk.size();
1536 if (legacy_request->key_info.body.pmk_info.pmk_len !=
1537 NAN_PMK_INFO_LEN) {
1538 LOG(ERROR)
1539 << "convertHidlNanSubscribeRequestToLegacy: invalid pmk_len";
1540 return false;
1541 }
1542 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1543 hidl_request.baseConfigs.securityConfig.pmk.data(),
1544 legacy_request->key_info.body.pmk_info.pmk_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001545 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001546 if (hidl_request.baseConfigs.securityConfig.securityType ==
1547 NanDataPathSecurityType::PASSPHRASE) {
1548 legacy_request->key_info.key_type =
1549 legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1550 legacy_request->key_info.body.passphrase_info.passphrase_len =
1551 hidl_request.baseConfigs.securityConfig.passphrase.size();
1552 if (legacy_request->key_info.body.passphrase_info.passphrase_len <
1553 NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1554 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1555 "passphrase_len too small";
1556 return false;
1557 }
1558 if (legacy_request->key_info.body.passphrase_info.passphrase_len >
1559 NAN_SECURITY_MAX_PASSPHRASE_LEN) {
1560 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1561 "passphrase_len too large";
1562 return false;
1563 }
1564 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1565 hidl_request.baseConfigs.securityConfig.passphrase.data(),
1566 legacy_request->key_info.body.passphrase_info.passphrase_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001567 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001568 legacy_request->sdea_params.security_cfg =
1569 (hidl_request.baseConfigs.securityConfig.securityType !=
1570 NanDataPathSecurityType::OPEN)
1571 ? legacy_hal::NAN_DP_CONFIG_SECURITY
1572 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
1573 legacy_request->sdea_params.ranging_state =
1574 hidl_request.baseConfigs.rangingRequired
1575 ? legacy_hal::NAN_RANGING_ENABLE
1576 : legacy_hal::NAN_RANGING_DISABLE;
1577 legacy_request->ranging_cfg.ranging_interval_msec =
1578 hidl_request.baseConfigs.rangingIntervalMsec;
1579 legacy_request->ranging_cfg.config_ranging_indications =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001580 hidl_request.baseConfigs.configRangingIndications;
Etan Cohen7b8c5d72017-12-14 18:12:04 -08001581 legacy_request->ranging_cfg.distance_ingress_mm =
1582 hidl_request.baseConfigs.distanceIngressCm * 10;
1583 legacy_request->ranging_cfg.distance_egress_mm =
1584 hidl_request.baseConfigs.distanceEgressCm * 10;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001585 legacy_request->ranging_auto_response =
1586 hidl_request.baseConfigs.rangingRequired
1587 ? legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE
1588 : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
1589 legacy_request->sdea_params.range_report =
1590 legacy_hal::NAN_DISABLE_RANGE_REPORT;
1591 legacy_request->subscribe_type =
1592 convertHidlNanSubscribeTypeToLegacy(hidl_request.subscribeType);
1593 legacy_request->serviceResponseFilter =
1594 convertHidlNanSrfTypeToLegacy(hidl_request.srfType);
1595 legacy_request->serviceResponseInclude =
1596 hidl_request.srfRespondIfInAddressSet
1597 ? legacy_hal::NAN_SRF_INCLUDE_RESPOND
1598 : legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
1599 legacy_request->useServiceResponseFilter =
1600 hidl_request.shouldUseSrf ? legacy_hal::NAN_USE_SRF
1601 : legacy_hal::NAN_DO_NOT_USE_SRF;
1602 legacy_request->ssiRequiredForMatchIndication =
1603 hidl_request.isSsiRequiredForMatch
1604 ? legacy_hal::NAN_SSI_REQUIRED_IN_MATCH_IND
1605 : legacy_hal::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND;
1606 legacy_request->num_intf_addr_present = hidl_request.intfAddr.size();
1607 if (legacy_request->num_intf_addr_present > NAN_MAX_SUBSCRIBE_MAX_ADDRESS) {
1608 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1609 "num_intf_addr_present - too many";
1610 return false;
1611 }
1612 for (int i = 0; i < legacy_request->num_intf_addr_present; i++) {
1613 memcpy(legacy_request->intf_addr[i], hidl_request.intfAddr[i].data(),
1614 6);
1615 }
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001616
Roshan Piusabcf78f2017-10-06 16:30:38 -07001617 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001618}
1619
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001620bool convertHidlNanTransmitFollowupRequestToLegacy(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001621 const NanTransmitFollowupRequest& hidl_request,
1622 legacy_hal::NanTransmitFollowupRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001623 if (!legacy_request) {
1624 LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
1625 "legacy_request is null";
1626 return false;
1627 }
1628 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001629
Roshan Piusabcf78f2017-10-06 16:30:38 -07001630 legacy_request->publish_subscribe_id = hidl_request.discoverySessionId;
1631 legacy_request->requestor_instance_id = hidl_request.peerId;
1632 memcpy(legacy_request->addr, hidl_request.addr.data(), 6);
1633 legacy_request->priority = hidl_request.isHighPriority
1634 ? legacy_hal::NAN_TX_PRIORITY_HIGH
1635 : legacy_hal::NAN_TX_PRIORITY_NORMAL;
1636 legacy_request->dw_or_faw = hidl_request.shouldUseDiscoveryWindow
1637 ? legacy_hal::NAN_TRANSMIT_IN_DW
1638 : legacy_hal::NAN_TRANSMIT_IN_FAW;
1639 legacy_request->service_specific_info_len =
1640 hidl_request.serviceSpecificInfo.size();
1641 if (legacy_request->service_specific_info_len >
1642 NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1643 LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
1644 "service_specific_info_len too large";
1645 return false;
1646 }
1647 memcpy(legacy_request->service_specific_info,
1648 hidl_request.serviceSpecificInfo.data(),
1649 legacy_request->service_specific_info_len);
1650 legacy_request->sdea_service_specific_info_len =
1651 hidl_request.extendedServiceSpecificInfo.size();
1652 if (legacy_request->sdea_service_specific_info_len >
1653 NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1654 LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
1655 "sdea_service_specific_info_len too large";
1656 return false;
1657 }
1658 memcpy(legacy_request->sdea_service_specific_info,
1659 hidl_request.extendedServiceSpecificInfo.data(),
1660 legacy_request->sdea_service_specific_info_len);
1661 legacy_request->recv_indication_cfg =
1662 hidl_request.disableFollowupResultIndication ? 0x1 : 0x0;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001663
Roshan Piusabcf78f2017-10-06 16:30:38 -07001664 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001665}
1666
1667bool convertHidlNanConfigRequestToLegacy(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001668 const NanConfigRequest& hidl_request,
1669 legacy_hal::NanConfigRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001670 if (!legacy_request) {
1671 LOG(ERROR)
1672 << "convertHidlNanConfigRequestToLegacy: legacy_request is null";
1673 return false;
1674 }
1675 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001676
Roshan Piusabcf78f2017-10-06 16:30:38 -07001677 // TODO: b/34059183 tracks missing configurations in legacy HAL or uknown
1678 // defaults
1679 legacy_request->master_pref = hidl_request.masterPref;
1680 legacy_request->discovery_indication_cfg = 0;
1681 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001682 hidl_request.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001683 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001684 hidl_request.disableStartedClusterIndication ? 0x2 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001685 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001686 hidl_request.disableJoinedClusterIndication ? 0x4 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001687 legacy_request->config_sid_beacon = 1;
1688 if (hidl_request.numberOfPublishServiceIdsInBeacon > 127) {
1689 LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: "
1690 "numberOfPublishServiceIdsInBeacon > 127";
1691 return false;
1692 }
1693 legacy_request->sid_beacon =
1694 (hidl_request.includePublishServiceIdsInBeacon ? 0x1 : 0x0) |
1695 (hidl_request.numberOfPublishServiceIdsInBeacon << 1);
1696 legacy_request->config_subscribe_sid_beacon = 1;
1697 if (hidl_request.numberOfSubscribeServiceIdsInBeacon > 127) {
1698 LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: "
1699 "numberOfSubscribeServiceIdsInBeacon > 127";
1700 return false;
1701 }
1702 legacy_request->subscribe_sid_beacon_val =
1703 (hidl_request.includeSubscribeServiceIdsInBeacon ? 0x1 : 0x0) |
1704 (hidl_request.numberOfSubscribeServiceIdsInBeacon << 1);
1705 legacy_request->config_rssi_window_size = 1;
1706 legacy_request->rssi_window_size_val = hidl_request.rssiWindowSize;
1707 legacy_request->config_disc_mac_addr_randomization = 1;
1708 legacy_request->disc_mac_addr_rand_interval_sec =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001709 hidl_request.macAddressRandomizationIntervalSec;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001710 /* TODO : missing
1711 legacy_request->config_2dot4g_rssi_close = 1;
1712 legacy_request->rssi_close_2dot4g_val =
1713 hidl_request.bandSpecificConfig[
1714 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiClose;
1715 legacy_request->config_2dot4g_rssi_middle = 1;
1716 legacy_request->rssi_middle_2dot4g_val =
1717 hidl_request.bandSpecificConfig[
1718 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiMiddle;
1719 legacy_request->config_2dot4g_rssi_proximity = 1;
1720 legacy_request->rssi_proximity_2dot4g_val =
1721 hidl_request.bandSpecificConfig[
1722 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiCloseProximity;
1723 */
1724 legacy_request->config_scan_params = 1;
1725 legacy_request->scan_params_val
1726 .dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
1727 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1728 .dwellTimeMs;
1729 legacy_request->scan_params_val
1730 .scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
1731 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1732 .scanPeriodSec;
1733 legacy_request->config_dw.config_2dot4g_dw_band =
1734 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1735 .validDiscoveryWindowIntervalVal;
1736 legacy_request->config_dw.dw_2dot4g_interval_val =
1737 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1738 .discoveryWindowIntervalVal;
1739 /* TODO: missing
1740 legacy_request->config_5g_rssi_close = 1;
1741 legacy_request->rssi_close_5g_val =
1742 hidl_request.bandSpecificConfig[
1743 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiClose;
1744 legacy_request->config_5g_rssi_middle = 1;
1745 legacy_request->rssi_middle_5g_val =
1746 hidl_request.bandSpecificConfig[
1747 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiMiddle;
1748 */
1749 legacy_request->config_5g_rssi_close_proximity = 1;
1750 legacy_request->rssi_close_proximity_5g_val =
1751 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1752 .rssiCloseProximity;
1753 legacy_request->scan_params_val
1754 .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1755 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1756 .dwellTimeMs;
1757 legacy_request->scan_params_val
1758 .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1759 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1760 .scanPeriodSec;
1761 legacy_request->scan_params_val
1762 .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1763 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1764 .dwellTimeMs;
1765 legacy_request->scan_params_val
1766 .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1767 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1768 .scanPeriodSec;
1769 legacy_request->config_dw.config_5g_dw_band =
1770 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1771 .validDiscoveryWindowIntervalVal;
1772 legacy_request->config_dw.dw_5g_interval_val =
1773 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1774 .discoveryWindowIntervalVal;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001775
Roshan Piusabcf78f2017-10-06 16:30:38 -07001776 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001777}
1778
Etan Cohen9e7a4052017-12-21 13:45:26 -08001779bool convertHidlNanConfigRequest_1_2ToLegacy(
1780 const NanConfigRequest& hidl_request1,
Jong Wook Kimda830c92018-07-23 15:29:38 -07001781 const V1_2::NanConfigRequestSupplemental& hidl_request2,
Etan Cohen9e7a4052017-12-21 13:45:26 -08001782 legacy_hal::NanConfigRequest* legacy_request) {
1783 if (!legacy_request) {
1784 LOG(ERROR) << "convertHidlNanConfigRequest_1_2ToLegacy: legacy_request "
1785 "is null";
1786 return false;
1787 }
1788
1789 *legacy_request = {};
1790 if (!convertHidlNanConfigRequestToLegacy(hidl_request1, legacy_request)) {
1791 return false;
1792 }
1793
1794 legacy_request->config_discovery_beacon_int = 1;
1795 legacy_request->discovery_beacon_interval =
1796 hidl_request2.discoveryBeaconIntervalMs;
1797 legacy_request->config_nss = 1;
1798 legacy_request->nss = hidl_request2.numberOfSpatialStreamsInDiscovery;
1799 legacy_request->config_dw_early_termination = 1;
1800 legacy_request->enable_dw_termination =
1801 hidl_request2.enableDiscoveryWindowEarlyTermination;
Etan Cohen4f5bc6c2017-12-28 13:08:08 -08001802 legacy_request->config_enable_ranging = 1;
1803 legacy_request->enable_ranging = hidl_request2.enableRanging;
Etan Cohen9e7a4052017-12-21 13:45:26 -08001804
1805 return true;
1806}
1807
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001808bool convertHidlNanDataPathInitiatorRequestToLegacy(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001809 const NanInitiateDataPathRequest& hidl_request,
1810 legacy_hal::NanDataPathInitiatorRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001811 if (!legacy_request) {
1812 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
1813 "legacy_request is null";
1814 return false;
1815 }
1816 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001817
Roshan Piusabcf78f2017-10-06 16:30:38 -07001818 legacy_request->requestor_instance_id = hidl_request.peerId;
1819 memcpy(legacy_request->peer_disc_mac_addr,
1820 hidl_request.peerDiscMacAddr.data(), 6);
1821 legacy_request->channel_request_type =
1822 convertHidlNanDataPathChannelCfgToLegacy(
1823 hidl_request.channelRequestType);
1824 legacy_request->channel = hidl_request.channel;
Etan Cohen1cefaf62019-11-25 11:41:58 -08001825 if (strnlen(hidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
1826 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
1827 "ifaceName too long";
1828 return false;
1829 }
1830 strncpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str(),
1831 IFNAMSIZ + 1);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001832 legacy_request->ndp_cfg.security_cfg =
1833 (hidl_request.securityConfig.securityType !=
1834 NanDataPathSecurityType::OPEN)
1835 ? legacy_hal::NAN_DP_CONFIG_SECURITY
Etan Cohenc58619e2017-03-14 14:54:40 -07001836 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001837 legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
1838 if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
1839 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
1840 "ndp_app_info_len too large";
1841 return false;
Etan Cohenc58619e2017-03-14 14:54:40 -07001842 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001843 memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
1844 legacy_request->app_info.ndp_app_info_len);
1845 legacy_request->cipher_type =
1846 (unsigned int)hidl_request.securityConfig.cipherType;
1847 if (hidl_request.securityConfig.securityType ==
1848 NanDataPathSecurityType::PMK) {
1849 legacy_request->key_info.key_type =
1850 legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1851 legacy_request->key_info.body.pmk_info.pmk_len =
1852 hidl_request.securityConfig.pmk.size();
1853 if (legacy_request->key_info.body.pmk_info.pmk_len !=
1854 NAN_PMK_INFO_LEN) {
1855 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
1856 "invalid pmk_len";
1857 return false;
1858 }
1859 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1860 hidl_request.securityConfig.pmk.data(),
1861 legacy_request->key_info.body.pmk_info.pmk_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001862 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001863 if (hidl_request.securityConfig.securityType ==
1864 NanDataPathSecurityType::PASSPHRASE) {
1865 legacy_request->key_info.key_type =
1866 legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1867 legacy_request->key_info.body.passphrase_info.passphrase_len =
1868 hidl_request.securityConfig.passphrase.size();
1869 if (legacy_request->key_info.body.passphrase_info.passphrase_len <
1870 NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1871 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
1872 "passphrase_len too small";
1873 return false;
1874 }
1875 if (legacy_request->key_info.body.passphrase_info.passphrase_len >
1876 NAN_SECURITY_MAX_PASSPHRASE_LEN) {
1877 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
1878 "passphrase_len too large";
1879 return false;
1880 }
1881 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1882 hidl_request.securityConfig.passphrase.data(),
1883 legacy_request->key_info.body.passphrase_info.passphrase_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001884 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001885 legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
1886 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1887 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
1888 "service_name_len too large";
1889 return false;
1890 }
1891 memcpy(legacy_request->service_name,
1892 hidl_request.serviceNameOutOfBand.data(),
1893 legacy_request->service_name_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001894
Roshan Piusabcf78f2017-10-06 16:30:38 -07001895 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001896}
1897
1898bool convertHidlNanDataPathIndicationResponseToLegacy(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001899 const NanRespondToDataPathIndicationRequest& hidl_request,
1900 legacy_hal::NanDataPathIndicationResponse* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001901 if (!legacy_request) {
1902 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
1903 "legacy_request is null";
1904 return false;
1905 }
1906 *legacy_request = {};
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001907
Roshan Piusabcf78f2017-10-06 16:30:38 -07001908 legacy_request->rsp_code = hidl_request.acceptRequest
1909 ? legacy_hal::NAN_DP_REQUEST_ACCEPT
1910 : legacy_hal::NAN_DP_REQUEST_REJECT;
1911 legacy_request->ndp_instance_id = hidl_request.ndpInstanceId;
Etan Cohen1cefaf62019-11-25 11:41:58 -08001912 if (strnlen(hidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
1913 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
1914 "ifaceName too long";
1915 return false;
1916 }
1917 strncpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str(),
1918 IFNAMSIZ + 1);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001919 legacy_request->ndp_cfg.security_cfg =
1920 (hidl_request.securityConfig.securityType !=
1921 NanDataPathSecurityType::OPEN)
1922 ? legacy_hal::NAN_DP_CONFIG_SECURITY
Etan Cohenc58619e2017-03-14 14:54:40 -07001923 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001924 legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
1925 if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
1926 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
1927 "ndp_app_info_len too large";
1928 return false;
Etan Cohenc58619e2017-03-14 14:54:40 -07001929 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001930 memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
1931 legacy_request->app_info.ndp_app_info_len);
1932 legacy_request->cipher_type =
1933 (unsigned int)hidl_request.securityConfig.cipherType;
1934 if (hidl_request.securityConfig.securityType ==
1935 NanDataPathSecurityType::PMK) {
1936 legacy_request->key_info.key_type =
1937 legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1938 legacy_request->key_info.body.pmk_info.pmk_len =
1939 hidl_request.securityConfig.pmk.size();
1940 if (legacy_request->key_info.body.pmk_info.pmk_len !=
1941 NAN_PMK_INFO_LEN) {
1942 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
1943 "invalid pmk_len";
1944 return false;
1945 }
1946 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1947 hidl_request.securityConfig.pmk.data(),
1948 legacy_request->key_info.body.pmk_info.pmk_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001949 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001950 if (hidl_request.securityConfig.securityType ==
1951 NanDataPathSecurityType::PASSPHRASE) {
1952 legacy_request->key_info.key_type =
1953 legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1954 legacy_request->key_info.body.passphrase_info.passphrase_len =
1955 hidl_request.securityConfig.passphrase.size();
1956 if (legacy_request->key_info.body.passphrase_info.passphrase_len <
1957 NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1958 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
1959 "passphrase_len too small";
1960 return false;
1961 }
1962 if (legacy_request->key_info.body.passphrase_info.passphrase_len >
1963 NAN_SECURITY_MAX_PASSPHRASE_LEN) {
1964 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
1965 "passphrase_len too large";
1966 return false;
1967 }
1968 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1969 hidl_request.securityConfig.passphrase.data(),
1970 legacy_request->key_info.body.passphrase_info.passphrase_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001971 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001972 legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
1973 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1974 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
1975 "service_name_len too large";
1976 return false;
1977 }
1978 memcpy(legacy_request->service_name,
1979 hidl_request.serviceNameOutOfBand.data(),
1980 legacy_request->service_name_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001981
Roshan Piusabcf78f2017-10-06 16:30:38 -07001982 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001983}
1984
1985bool convertLegacyNanResponseHeaderToHidl(
1986 const legacy_hal::NanResponseMsg& legacy_response,
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001987 WifiNanStatus* wifiNanStatus) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001988 if (!wifiNanStatus) {
1989 LOG(ERROR)
1990 << "convertLegacyNanResponseHeaderToHidl: wifiNanStatus is null";
1991 return false;
1992 }
1993 *wifiNanStatus = {};
Roshan Pius590744b2017-03-02 07:24:41 -08001994
Roshan Piusabcf78f2017-10-06 16:30:38 -07001995 convertToWifiNanStatus(legacy_response.status, legacy_response.nan_error,
1996 sizeof(legacy_response.nan_error), wifiNanStatus);
1997 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001998}
1999
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002000bool convertLegacyNanCapabilitiesResponseToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002001 const legacy_hal::NanCapabilities& legacy_response,
2002 NanCapabilities* hidl_response) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002003 if (!hidl_response) {
2004 LOG(ERROR) << "convertLegacyNanCapabilitiesResponseToHidl: "
2005 "hidl_response is null";
2006 return false;
2007 }
2008 *hidl_response = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002009
Roshan Piusabcf78f2017-10-06 16:30:38 -07002010 hidl_response->maxConcurrentClusters =
2011 legacy_response.max_concurrent_nan_clusters;
2012 hidl_response->maxPublishes = legacy_response.max_publishes;
2013 hidl_response->maxSubscribes = legacy_response.max_subscribes;
2014 hidl_response->maxServiceNameLen = legacy_response.max_service_name_len;
2015 hidl_response->maxMatchFilterLen = legacy_response.max_match_filter_len;
2016 hidl_response->maxTotalMatchFilterLen =
2017 legacy_response.max_total_match_filter_len;
2018 hidl_response->maxServiceSpecificInfoLen =
2019 legacy_response.max_service_specific_info_len;
2020 hidl_response->maxExtendedServiceSpecificInfoLen =
2021 legacy_response.max_sdea_service_specific_info_len;
2022 hidl_response->maxNdiInterfaces = legacy_response.max_ndi_interfaces;
2023 hidl_response->maxNdpSessions = legacy_response.max_ndp_sessions;
2024 hidl_response->maxAppInfoLen = legacy_response.max_app_info_len;
2025 hidl_response->maxQueuedTransmitFollowupMsgs =
2026 legacy_response.max_queued_transmit_followup_msgs;
2027 hidl_response->maxSubscribeInterfaceAddresses =
2028 legacy_response.max_subscribe_address;
2029 hidl_response->supportedCipherSuites =
2030 legacy_response.cipher_suites_supported;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002031
Roshan Piusabcf78f2017-10-06 16:30:38 -07002032 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002033}
2034
Roshan Piusabcf78f2017-10-06 16:30:38 -07002035bool convertLegacyNanMatchIndToHidl(const legacy_hal::NanMatchInd& legacy_ind,
2036 NanMatchInd* hidl_ind) {
2037 if (!hidl_ind) {
2038 LOG(ERROR) << "convertLegacyNanMatchIndToHidl: hidl_ind is null";
2039 return false;
2040 }
2041 *hidl_ind = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002042
Roshan Piusabcf78f2017-10-06 16:30:38 -07002043 hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
2044 hidl_ind->peerId = legacy_ind.requestor_instance_id;
2045 hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
2046 hidl_ind->serviceSpecificInfo =
2047 std::vector<uint8_t>(legacy_ind.service_specific_info,
2048 legacy_ind.service_specific_info +
2049 legacy_ind.service_specific_info_len);
2050 hidl_ind->extendedServiceSpecificInfo =
2051 std::vector<uint8_t>(legacy_ind.sdea_service_specific_info,
2052 legacy_ind.sdea_service_specific_info +
2053 legacy_ind.sdea_service_specific_info_len);
2054 hidl_ind->matchFilter = std::vector<uint8_t>(
2055 legacy_ind.sdf_match_filter,
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002056 legacy_ind.sdf_match_filter + legacy_ind.sdf_match_filter_len);
Roshan Piusabcf78f2017-10-06 16:30:38 -07002057 hidl_ind->matchOccuredInBeaconFlag = legacy_ind.match_occured_flag == 1;
2058 hidl_ind->outOfResourceFlag = legacy_ind.out_of_resource_flag == 1;
2059 hidl_ind->rssiValue = legacy_ind.rssi_value;
2060 hidl_ind->peerCipherType = (NanCipherSuiteType)legacy_ind.peer_cipher_type;
2061 hidl_ind->peerRequiresSecurityEnabledInNdp =
2062 legacy_ind.peer_sdea_params.security_cfg ==
2063 legacy_hal::NAN_DP_CONFIG_SECURITY;
2064 hidl_ind->peerRequiresRanging = legacy_ind.peer_sdea_params.ranging_state ==
2065 legacy_hal::NAN_RANGING_ENABLE;
2066 hidl_ind->rangingMeasurementInCm =
Etan Cohen7b8c5d72017-12-14 18:12:04 -08002067 legacy_ind.range_info.range_measurement_mm / 10;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002068 hidl_ind->rangingIndicationType = legacy_ind.range_info.ranging_event_type;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002069
Roshan Piusabcf78f2017-10-06 16:30:38 -07002070 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002071}
2072
2073bool convertLegacyNanFollowupIndToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002074 const legacy_hal::NanFollowupInd& legacy_ind,
2075 NanFollowupReceivedInd* hidl_ind) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002076 if (!hidl_ind) {
2077 LOG(ERROR) << "convertLegacyNanFollowupIndToHidl: hidl_ind is null";
2078 return false;
2079 }
2080 *hidl_ind = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002081
Roshan Piusabcf78f2017-10-06 16:30:38 -07002082 hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
2083 hidl_ind->peerId = legacy_ind.requestor_instance_id;
2084 hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
2085 hidl_ind->receivedInFaw = legacy_ind.dw_or_faw == 1;
2086 hidl_ind->serviceSpecificInfo =
2087 std::vector<uint8_t>(legacy_ind.service_specific_info,
2088 legacy_ind.service_specific_info +
2089 legacy_ind.service_specific_info_len);
2090 hidl_ind->extendedServiceSpecificInfo =
2091 std::vector<uint8_t>(legacy_ind.sdea_service_specific_info,
2092 legacy_ind.sdea_service_specific_info +
2093 legacy_ind.sdea_service_specific_info_len);
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002094
Roshan Piusabcf78f2017-10-06 16:30:38 -07002095 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002096}
2097
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002098bool convertLegacyNanDataPathRequestIndToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002099 const legacy_hal::NanDataPathRequestInd& legacy_ind,
2100 NanDataPathRequestInd* hidl_ind) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002101 if (!hidl_ind) {
2102 LOG(ERROR)
2103 << "convertLegacyNanDataPathRequestIndToHidl: hidl_ind is null";
2104 return false;
2105 }
2106 *hidl_ind = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002107
Roshan Piusabcf78f2017-10-06 16:30:38 -07002108 hidl_ind->discoverySessionId = legacy_ind.service_instance_id;
2109 hidl_ind->peerDiscMacAddr =
2110 hidl_array<uint8_t, 6>(legacy_ind.peer_disc_mac_addr);
2111 hidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
2112 hidl_ind->securityRequired =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002113 legacy_ind.ndp_cfg.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002114 hidl_ind->appInfo =
2115 std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info,
2116 legacy_ind.app_info.ndp_app_info +
2117 legacy_ind.app_info.ndp_app_info_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002118
Roshan Piusabcf78f2017-10-06 16:30:38 -07002119 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002120}
2121
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002122bool convertLegacyNdpChannelInfoToHidl(
2123 const legacy_hal::NanChannelInfo& legacy_struct,
Jong Wook Kimda830c92018-07-23 15:29:38 -07002124 V1_2::NanDataPathChannelInfo* hidl_struct) {
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002125 if (!hidl_struct) {
2126 LOG(ERROR) << "convertLegacyNdpChannelInfoToHidl: hidl_struct is null";
2127 return false;
2128 }
2129 *hidl_struct = {};
2130
2131 hidl_struct->channelFreq = legacy_struct.channel;
Etan Cohenb1b7a822018-02-07 14:44:32 -08002132 hidl_struct->channelBandwidth = convertLegacyWifiChannelWidthToHidl(
2133 (legacy_hal::wifi_channel_width)legacy_struct.bandwidth);
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002134 hidl_struct->numSpatialStreams = legacy_struct.nss;
2135
2136 return true;
2137}
2138
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002139bool convertLegacyNanDataPathConfirmIndToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002140 const legacy_hal::NanDataPathConfirmInd& legacy_ind,
Jong Wook Kimda830c92018-07-23 15:29:38 -07002141 V1_2::NanDataPathConfirmInd* hidl_ind) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002142 if (!hidl_ind) {
2143 LOG(ERROR)
2144 << "convertLegacyNanDataPathConfirmIndToHidl: hidl_ind is null";
2145 return false;
2146 }
2147 *hidl_ind = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002148
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002149 hidl_ind->V1_0.ndpInstanceId = legacy_ind.ndp_instance_id;
2150 hidl_ind->V1_0.dataPathSetupSuccess =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002151 legacy_ind.rsp_code == legacy_hal::NAN_DP_REQUEST_ACCEPT;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002152 hidl_ind->V1_0.peerNdiMacAddr =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002153 hidl_array<uint8_t, 6>(legacy_ind.peer_ndi_mac_addr);
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002154 hidl_ind->V1_0.appInfo =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002155 std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info,
2156 legacy_ind.app_info.ndp_app_info +
2157 legacy_ind.app_info.ndp_app_info_len);
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002158 hidl_ind->V1_0.status.status =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002159 convertLegacyNanStatusTypeToHidl(legacy_ind.reason_code);
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002160 hidl_ind->V1_0.status.description = ""; // TODO: b/34059183
2161
Jong Wook Kimda830c92018-07-23 15:29:38 -07002162 std::vector<V1_2::NanDataPathChannelInfo> channelInfo;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002163 for (unsigned int i = 0; i < legacy_ind.num_channels; ++i) {
Jong Wook Kimda830c92018-07-23 15:29:38 -07002164 V1_2::NanDataPathChannelInfo hidl_struct;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002165 if (!convertLegacyNdpChannelInfoToHidl(legacy_ind.channel_info[i],
2166 &hidl_struct)) {
2167 return false;
2168 }
2169 channelInfo.push_back(hidl_struct);
2170 }
2171 hidl_ind->channelInfo = channelInfo;
2172
2173 return true;
2174}
2175
2176bool convertLegacyNanDataPathScheduleUpdateIndToHidl(
2177 const legacy_hal::NanDataPathScheduleUpdateInd& legacy_ind,
Jong Wook Kimda830c92018-07-23 15:29:38 -07002178 V1_2::NanDataPathScheduleUpdateInd* hidl_ind) {
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002179 if (!hidl_ind) {
2180 LOG(ERROR) << "convertLegacyNanDataPathScheduleUpdateIndToHidl: "
2181 "hidl_ind is null";
2182 return false;
2183 }
2184 *hidl_ind = {};
2185
2186 hidl_ind->peerDiscoveryAddress =
2187 hidl_array<uint8_t, 6>(legacy_ind.peer_mac_addr);
Jong Wook Kimda830c92018-07-23 15:29:38 -07002188 std::vector<V1_2::NanDataPathChannelInfo> channelInfo;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002189 for (unsigned int i = 0; i < legacy_ind.num_channels; ++i) {
Jong Wook Kimda830c92018-07-23 15:29:38 -07002190 V1_2::NanDataPathChannelInfo hidl_struct;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002191 if (!convertLegacyNdpChannelInfoToHidl(legacy_ind.channel_info[i],
2192 &hidl_struct)) {
2193 return false;
2194 }
2195 channelInfo.push_back(hidl_struct);
2196 }
2197 hidl_ind->channelInfo = channelInfo;
2198 std::vector<uint32_t> ndpInstanceIds;
2199 for (unsigned int i = 0; i < legacy_ind.num_ndp_instances; ++i) {
2200 ndpInstanceIds.push_back(legacy_ind.ndp_instance_id[i]);
2201 }
2202 hidl_ind->ndpInstanceIds = ndpInstanceIds;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002203
Roshan Piusabcf78f2017-10-06 16:30:38 -07002204 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002205}
Roshan Pius3fae9c82016-12-02 14:49:41 -08002206
2207legacy_hal::wifi_rtt_type convertHidlRttTypeToLegacy(RttType type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002208 switch (type) {
2209 case RttType::ONE_SIDED:
2210 return legacy_hal::RTT_TYPE_1_SIDED;
2211 case RttType::TWO_SIDED:
2212 return legacy_hal::RTT_TYPE_2_SIDED;
2213 };
2214 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002215}
2216
2217RttType convertLegacyRttTypeToHidl(legacy_hal::wifi_rtt_type type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002218 switch (type) {
2219 case legacy_hal::RTT_TYPE_1_SIDED:
2220 return RttType::ONE_SIDED;
2221 case legacy_hal::RTT_TYPE_2_SIDED:
2222 return RttType::TWO_SIDED;
2223 };
2224 CHECK(false) << "Unknown legacy type: " << type;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002225}
2226
2227legacy_hal::rtt_peer_type convertHidlRttPeerTypeToLegacy(RttPeerType type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002228 switch (type) {
2229 case RttPeerType::AP:
2230 return legacy_hal::RTT_PEER_AP;
2231 case RttPeerType::STA:
2232 return legacy_hal::RTT_PEER_STA;
2233 case RttPeerType::P2P_GO:
2234 return legacy_hal::RTT_PEER_P2P_GO;
2235 case RttPeerType::P2P_CLIENT:
2236 return legacy_hal::RTT_PEER_P2P_CLIENT;
2237 case RttPeerType::NAN:
2238 return legacy_hal::RTT_PEER_NAN;
2239 };
2240 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002241}
2242
2243legacy_hal::wifi_channel_width convertHidlWifiChannelWidthToLegacy(
2244 WifiChannelWidthInMhz type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002245 switch (type) {
2246 case WifiChannelWidthInMhz::WIDTH_20:
2247 return legacy_hal::WIFI_CHAN_WIDTH_20;
2248 case WifiChannelWidthInMhz::WIDTH_40:
2249 return legacy_hal::WIFI_CHAN_WIDTH_40;
2250 case WifiChannelWidthInMhz::WIDTH_80:
2251 return legacy_hal::WIFI_CHAN_WIDTH_80;
2252 case WifiChannelWidthInMhz::WIDTH_160:
2253 return legacy_hal::WIFI_CHAN_WIDTH_160;
2254 case WifiChannelWidthInMhz::WIDTH_80P80:
2255 return legacy_hal::WIFI_CHAN_WIDTH_80P80;
2256 case WifiChannelWidthInMhz::WIDTH_5:
2257 return legacy_hal::WIFI_CHAN_WIDTH_5;
2258 case WifiChannelWidthInMhz::WIDTH_10:
2259 return legacy_hal::WIFI_CHAN_WIDTH_10;
2260 case WifiChannelWidthInMhz::WIDTH_INVALID:
2261 return legacy_hal::WIFI_CHAN_WIDTH_INVALID;
2262 };
2263 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002264}
2265
2266WifiChannelWidthInMhz convertLegacyWifiChannelWidthToHidl(
2267 legacy_hal::wifi_channel_width type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002268 switch (type) {
2269 case legacy_hal::WIFI_CHAN_WIDTH_20:
2270 return WifiChannelWidthInMhz::WIDTH_20;
2271 case legacy_hal::WIFI_CHAN_WIDTH_40:
2272 return WifiChannelWidthInMhz::WIDTH_40;
2273 case legacy_hal::WIFI_CHAN_WIDTH_80:
2274 return WifiChannelWidthInMhz::WIDTH_80;
2275 case legacy_hal::WIFI_CHAN_WIDTH_160:
2276 return WifiChannelWidthInMhz::WIDTH_160;
2277 case legacy_hal::WIFI_CHAN_WIDTH_80P80:
2278 return WifiChannelWidthInMhz::WIDTH_80P80;
2279 case legacy_hal::WIFI_CHAN_WIDTH_5:
2280 return WifiChannelWidthInMhz::WIDTH_5;
2281 case legacy_hal::WIFI_CHAN_WIDTH_10:
2282 return WifiChannelWidthInMhz::WIDTH_10;
2283 case legacy_hal::WIFI_CHAN_WIDTH_INVALID:
2284 return WifiChannelWidthInMhz::WIDTH_INVALID;
2285 };
2286 CHECK(false) << "Unknown legacy type: " << type;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002287}
2288
2289legacy_hal::wifi_rtt_preamble convertHidlRttPreambleToLegacy(RttPreamble type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002290 switch (type) {
2291 case RttPreamble::LEGACY:
2292 return legacy_hal::WIFI_RTT_PREAMBLE_LEGACY;
2293 case RttPreamble::HT:
2294 return legacy_hal::WIFI_RTT_PREAMBLE_HT;
2295 case RttPreamble::VHT:
2296 return legacy_hal::WIFI_RTT_PREAMBLE_VHT;
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07002297 case RttPreamble::HE:
2298 return legacy_hal::WIFI_RTT_PREAMBLE_HE;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002299 };
2300 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002301}
2302
2303RttPreamble convertLegacyRttPreambleToHidl(legacy_hal::wifi_rtt_preamble type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002304 switch (type) {
2305 case legacy_hal::WIFI_RTT_PREAMBLE_LEGACY:
2306 return RttPreamble::LEGACY;
2307 case legacy_hal::WIFI_RTT_PREAMBLE_HT:
2308 return RttPreamble::HT;
2309 case legacy_hal::WIFI_RTT_PREAMBLE_VHT:
2310 return RttPreamble::VHT;
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07002311 case legacy_hal::WIFI_RTT_PREAMBLE_HE:
2312 return RttPreamble::HE;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002313 };
2314 CHECK(false) << "Unknown legacy type: " << type;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002315}
2316
2317legacy_hal::wifi_rtt_bw convertHidlRttBwToLegacy(RttBw type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002318 switch (type) {
2319 case RttBw::BW_5MHZ:
2320 return legacy_hal::WIFI_RTT_BW_5;
2321 case RttBw::BW_10MHZ:
2322 return legacy_hal::WIFI_RTT_BW_10;
2323 case RttBw::BW_20MHZ:
2324 return legacy_hal::WIFI_RTT_BW_20;
2325 case RttBw::BW_40MHZ:
2326 return legacy_hal::WIFI_RTT_BW_40;
2327 case RttBw::BW_80MHZ:
2328 return legacy_hal::WIFI_RTT_BW_80;
2329 case RttBw::BW_160MHZ:
2330 return legacy_hal::WIFI_RTT_BW_160;
2331 };
2332 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002333}
2334
2335RttBw convertLegacyRttBwToHidl(legacy_hal::wifi_rtt_bw type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002336 switch (type) {
2337 case legacy_hal::WIFI_RTT_BW_5:
2338 return RttBw::BW_5MHZ;
2339 case legacy_hal::WIFI_RTT_BW_10:
2340 return RttBw::BW_10MHZ;
2341 case legacy_hal::WIFI_RTT_BW_20:
2342 return RttBw::BW_20MHZ;
2343 case legacy_hal::WIFI_RTT_BW_40:
2344 return RttBw::BW_40MHZ;
2345 case legacy_hal::WIFI_RTT_BW_80:
2346 return RttBw::BW_80MHZ;
2347 case legacy_hal::WIFI_RTT_BW_160:
2348 return RttBw::BW_160MHZ;
2349 };
2350 CHECK(false) << "Unknown legacy type: " << type;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002351}
2352
2353legacy_hal::wifi_motion_pattern convertHidlRttMotionPatternToLegacy(
2354 RttMotionPattern type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002355 switch (type) {
2356 case RttMotionPattern::NOT_EXPECTED:
2357 return legacy_hal::WIFI_MOTION_NOT_EXPECTED;
2358 case RttMotionPattern::EXPECTED:
2359 return legacy_hal::WIFI_MOTION_EXPECTED;
2360 case RttMotionPattern::UNKNOWN:
2361 return legacy_hal::WIFI_MOTION_UNKNOWN;
2362 };
2363 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002364}
2365
2366WifiRatePreamble convertLegacyWifiRatePreambleToHidl(uint8_t preamble) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002367 switch (preamble) {
2368 case 0:
2369 return WifiRatePreamble::OFDM;
2370 case 1:
2371 return WifiRatePreamble::CCK;
2372 case 2:
2373 return WifiRatePreamble::HT;
2374 case 3:
2375 return WifiRatePreamble::VHT;
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07002376 case 4:
2377 return WifiRatePreamble::HE;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002378 default:
2379 return WifiRatePreamble::RESERVED;
2380 };
2381 CHECK(false) << "Unknown legacy preamble: " << preamble;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002382}
2383
2384WifiRateNss convertLegacyWifiRateNssToHidl(uint8_t nss) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002385 switch (nss) {
2386 case 0:
2387 return WifiRateNss::NSS_1x1;
2388 case 1:
2389 return WifiRateNss::NSS_2x2;
2390 case 2:
2391 return WifiRateNss::NSS_3x3;
2392 case 3:
2393 return WifiRateNss::NSS_4x4;
2394 };
2395 CHECK(false) << "Unknown legacy nss: " << nss;
2396 return {};
Roshan Pius3fae9c82016-12-02 14:49:41 -08002397}
2398
2399RttStatus convertLegacyRttStatusToHidl(legacy_hal::wifi_rtt_status status) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002400 switch (status) {
2401 case legacy_hal::RTT_STATUS_SUCCESS:
2402 return RttStatus::SUCCESS;
2403 case legacy_hal::RTT_STATUS_FAILURE:
2404 return RttStatus::FAILURE;
2405 case legacy_hal::RTT_STATUS_FAIL_NO_RSP:
2406 return RttStatus::FAIL_NO_RSP;
2407 case legacy_hal::RTT_STATUS_FAIL_REJECTED:
2408 return RttStatus::FAIL_REJECTED;
2409 case legacy_hal::RTT_STATUS_FAIL_NOT_SCHEDULED_YET:
2410 return RttStatus::FAIL_NOT_SCHEDULED_YET;
2411 case legacy_hal::RTT_STATUS_FAIL_TM_TIMEOUT:
2412 return RttStatus::FAIL_TM_TIMEOUT;
2413 case legacy_hal::RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL:
2414 return RttStatus::FAIL_AP_ON_DIFF_CHANNEL;
2415 case legacy_hal::RTT_STATUS_FAIL_NO_CAPABILITY:
2416 return RttStatus::FAIL_NO_CAPABILITY;
2417 case legacy_hal::RTT_STATUS_ABORTED:
2418 return RttStatus::ABORTED;
2419 case legacy_hal::RTT_STATUS_FAIL_INVALID_TS:
2420 return RttStatus::FAIL_INVALID_TS;
2421 case legacy_hal::RTT_STATUS_FAIL_PROTOCOL:
2422 return RttStatus::FAIL_PROTOCOL;
2423 case legacy_hal::RTT_STATUS_FAIL_SCHEDULE:
2424 return RttStatus::FAIL_SCHEDULE;
2425 case legacy_hal::RTT_STATUS_FAIL_BUSY_TRY_LATER:
2426 return RttStatus::FAIL_BUSY_TRY_LATER;
2427 case legacy_hal::RTT_STATUS_INVALID_REQ:
2428 return RttStatus::INVALID_REQ;
2429 case legacy_hal::RTT_STATUS_NO_WIFI:
2430 return RttStatus::NO_WIFI;
2431 case legacy_hal::RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE:
2432 return RttStatus::FAIL_FTM_PARAM_OVERRIDE;
Etan Cohen69c89222018-03-08 13:39:19 -08002433 case legacy_hal::RTT_STATUS_NAN_RANGING_PROTOCOL_FAILURE:
2434 return RttStatus::FAILURE; // TODO: add HIDL enumeration
2435 case legacy_hal::RTT_STATUS_NAN_RANGING_CONCURRENCY_NOT_SUPPORTED:
2436 return RttStatus::FAILURE; // TODO: add HIDL enumeration
Roshan Piusabcf78f2017-10-06 16:30:38 -07002437 };
2438 CHECK(false) << "Unknown legacy status: " << status;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002439}
2440
2441bool convertHidlWifiChannelInfoToLegacy(
2442 const WifiChannelInfo& hidl_info,
2443 legacy_hal::wifi_channel_info* legacy_info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002444 if (!legacy_info) {
2445 return false;
2446 }
2447 *legacy_info = {};
2448 legacy_info->width = convertHidlWifiChannelWidthToLegacy(hidl_info.width);
2449 legacy_info->center_freq = hidl_info.centerFreq;
2450 legacy_info->center_freq0 = hidl_info.centerFreq0;
2451 legacy_info->center_freq1 = hidl_info.centerFreq1;
2452 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002453}
2454
2455bool convertLegacyWifiChannelInfoToHidl(
2456 const legacy_hal::wifi_channel_info& legacy_info,
2457 WifiChannelInfo* hidl_info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002458 if (!hidl_info) {
2459 return false;
2460 }
2461 *hidl_info = {};
2462 hidl_info->width = convertLegacyWifiChannelWidthToHidl(legacy_info.width);
2463 hidl_info->centerFreq = legacy_info.center_freq;
2464 hidl_info->centerFreq0 = legacy_info.center_freq0;
2465 hidl_info->centerFreq1 = legacy_info.center_freq1;
2466 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002467}
2468
2469bool convertHidlRttConfigToLegacy(const RttConfig& hidl_config,
2470 legacy_hal::wifi_rtt_config* legacy_config) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002471 if (!legacy_config) {
2472 return false;
2473 }
2474 *legacy_config = {};
2475 CHECK(hidl_config.addr.size() == sizeof(legacy_config->addr));
2476 memcpy(legacy_config->addr, hidl_config.addr.data(),
2477 hidl_config.addr.size());
2478 legacy_config->type = convertHidlRttTypeToLegacy(hidl_config.type);
2479 legacy_config->peer = convertHidlRttPeerTypeToLegacy(hidl_config.peer);
2480 if (!convertHidlWifiChannelInfoToLegacy(hidl_config.channel,
2481 &legacy_config->channel)) {
2482 return false;
2483 }
2484 legacy_config->burst_period = hidl_config.burstPeriod;
2485 legacy_config->num_burst = hidl_config.numBurst;
2486 legacy_config->num_frames_per_burst = hidl_config.numFramesPerBurst;
2487 legacy_config->num_retries_per_rtt_frame =
2488 hidl_config.numRetriesPerRttFrame;
2489 legacy_config->num_retries_per_ftmr = hidl_config.numRetriesPerFtmr;
2490 legacy_config->LCI_request = hidl_config.mustRequestLci;
2491 legacy_config->LCR_request = hidl_config.mustRequestLcr;
2492 legacy_config->burst_duration = hidl_config.burstDuration;
2493 legacy_config->preamble =
2494 convertHidlRttPreambleToLegacy(hidl_config.preamble);
2495 legacy_config->bw = convertHidlRttBwToLegacy(hidl_config.bw);
2496 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002497}
2498
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002499bool convertHidlVectorOfRttConfigToLegacy(
2500 const std::vector<RttConfig>& hidl_configs,
2501 std::vector<legacy_hal::wifi_rtt_config>* legacy_configs) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002502 if (!legacy_configs) {
2503 return false;
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002504 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002505 *legacy_configs = {};
2506 for (const auto& hidl_config : hidl_configs) {
2507 legacy_hal::wifi_rtt_config legacy_config;
2508 if (!convertHidlRttConfigToLegacy(hidl_config, &legacy_config)) {
2509 return false;
2510 }
2511 legacy_configs->push_back(legacy_config);
2512 }
2513 return true;
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002514}
2515
Roshan Pius3fae9c82016-12-02 14:49:41 -08002516bool convertHidlRttLciInformationToLegacy(
2517 const RttLciInformation& hidl_info,
2518 legacy_hal::wifi_lci_information* legacy_info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002519 if (!legacy_info) {
2520 return false;
2521 }
2522 *legacy_info = {};
2523 legacy_info->latitude = hidl_info.latitude;
2524 legacy_info->longitude = hidl_info.longitude;
2525 legacy_info->altitude = hidl_info.altitude;
2526 legacy_info->latitude_unc = hidl_info.latitudeUnc;
2527 legacy_info->longitude_unc = hidl_info.longitudeUnc;
2528 legacy_info->altitude_unc = hidl_info.altitudeUnc;
2529 legacy_info->motion_pattern =
2530 convertHidlRttMotionPatternToLegacy(hidl_info.motionPattern);
2531 legacy_info->floor = hidl_info.floor;
2532 legacy_info->height_above_floor = hidl_info.heightAboveFloor;
2533 legacy_info->height_unc = hidl_info.heightUnc;
2534 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002535}
2536
2537bool convertHidlRttLcrInformationToLegacy(
2538 const RttLcrInformation& hidl_info,
2539 legacy_hal::wifi_lcr_information* legacy_info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002540 if (!legacy_info) {
2541 return false;
2542 }
2543 *legacy_info = {};
2544 CHECK(hidl_info.countryCode.size() == sizeof(legacy_info->country_code));
2545 memcpy(legacy_info->country_code, hidl_info.countryCode.data(),
2546 hidl_info.countryCode.size());
2547 if (hidl_info.civicInfo.size() > sizeof(legacy_info->civic_info)) {
2548 return false;
2549 }
2550 legacy_info->length = hidl_info.civicInfo.size();
2551 memcpy(legacy_info->civic_info, hidl_info.civicInfo.c_str(),
2552 hidl_info.civicInfo.size());
2553 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002554}
2555
2556bool convertHidlRttResponderToLegacy(
2557 const RttResponder& hidl_responder,
2558 legacy_hal::wifi_rtt_responder* legacy_responder) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002559 if (!legacy_responder) {
2560 return false;
2561 }
2562 *legacy_responder = {};
2563 if (!convertHidlWifiChannelInfoToLegacy(hidl_responder.channel,
2564 &legacy_responder->channel)) {
2565 return false;
2566 }
2567 legacy_responder->preamble =
2568 convertHidlRttPreambleToLegacy(hidl_responder.preamble);
2569 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002570}
2571
2572bool convertLegacyRttResponderToHidl(
2573 const legacy_hal::wifi_rtt_responder& legacy_responder,
2574 RttResponder* hidl_responder) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002575 if (!hidl_responder) {
2576 return false;
2577 }
2578 *hidl_responder = {};
2579 if (!convertLegacyWifiChannelInfoToHidl(legacy_responder.channel,
2580 &hidl_responder->channel)) {
2581 return false;
2582 }
2583 hidl_responder->preamble =
2584 convertLegacyRttPreambleToHidl(legacy_responder.preamble);
2585 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002586}
2587
2588bool convertLegacyRttCapabilitiesToHidl(
2589 const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
2590 RttCapabilities* hidl_capabilities) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002591 if (!hidl_capabilities) {
2592 return false;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002593 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002594 *hidl_capabilities = {};
2595 hidl_capabilities->rttOneSidedSupported =
2596 legacy_capabilities.rtt_one_sided_supported;
2597 hidl_capabilities->rttFtmSupported = legacy_capabilities.rtt_ftm_supported;
2598 hidl_capabilities->lciSupported = legacy_capabilities.lci_support;
2599 hidl_capabilities->lcrSupported = legacy_capabilities.lcr_support;
2600 hidl_capabilities->responderSupported =
2601 legacy_capabilities.responder_supported;
2602 hidl_capabilities->preambleSupport = 0;
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07002603 for (const auto flag :
2604 {legacy_hal::WIFI_RTT_PREAMBLE_LEGACY,
2605 legacy_hal::WIFI_RTT_PREAMBLE_HT, legacy_hal::WIFI_RTT_PREAMBLE_VHT,
2606 legacy_hal::WIFI_RTT_PREAMBLE_HE}) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002607 if (legacy_capabilities.preamble_support & flag) {
2608 hidl_capabilities->preambleSupport |=
2609 static_cast<std::underlying_type<RttPreamble>::type>(
2610 convertLegacyRttPreambleToHidl(flag));
2611 }
Roshan Pius3fae9c82016-12-02 14:49:41 -08002612 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002613 hidl_capabilities->bwSupport = 0;
2614 for (const auto flag :
2615 {legacy_hal::WIFI_RTT_BW_5, legacy_hal::WIFI_RTT_BW_10,
2616 legacy_hal::WIFI_RTT_BW_20, legacy_hal::WIFI_RTT_BW_40,
2617 legacy_hal::WIFI_RTT_BW_80, legacy_hal::WIFI_RTT_BW_160}) {
2618 if (legacy_capabilities.bw_support & flag) {
2619 hidl_capabilities->bwSupport |=
2620 static_cast<std::underlying_type<RttBw>::type>(
2621 convertLegacyRttBwToHidl(flag));
2622 }
2623 }
2624 hidl_capabilities->mcVersion = legacy_capabilities.mc_version;
2625 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002626}
2627
2628bool convertLegacyWifiRateInfoToHidl(const legacy_hal::wifi_rate& legacy_rate,
2629 WifiRateInfo* hidl_rate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002630 if (!hidl_rate) {
2631 return false;
2632 }
2633 *hidl_rate = {};
2634 hidl_rate->preamble =
2635 convertLegacyWifiRatePreambleToHidl(legacy_rate.preamble);
2636 hidl_rate->nss = convertLegacyWifiRateNssToHidl(legacy_rate.nss);
2637 hidl_rate->bw = convertLegacyWifiChannelWidthToHidl(
2638 static_cast<legacy_hal::wifi_channel_width>(legacy_rate.bw));
2639 hidl_rate->rateMcsIdx = legacy_rate.rateMcsIdx;
2640 hidl_rate->bitRateInKbps = legacy_rate.bitrate;
2641 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002642}
2643
2644bool convertLegacyRttResultToHidl(
2645 const legacy_hal::wifi_rtt_result& legacy_result, RttResult* hidl_result) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002646 if (!hidl_result) {
2647 return false;
2648 }
2649 *hidl_result = {};
2650 CHECK(sizeof(legacy_result.addr) == hidl_result->addr.size());
2651 memcpy(hidl_result->addr.data(), legacy_result.addr,
2652 sizeof(legacy_result.addr));
2653 hidl_result->burstNum = legacy_result.burst_num;
2654 hidl_result->measurementNumber = legacy_result.measurement_number;
2655 hidl_result->successNumber = legacy_result.success_number;
2656 hidl_result->numberPerBurstPeer = legacy_result.number_per_burst_peer;
2657 hidl_result->status = convertLegacyRttStatusToHidl(legacy_result.status);
2658 hidl_result->retryAfterDuration = legacy_result.retry_after_duration;
2659 hidl_result->type = convertLegacyRttTypeToHidl(legacy_result.type);
2660 hidl_result->rssi = legacy_result.rssi;
2661 hidl_result->rssiSpread = legacy_result.rssi_spread;
2662 if (!convertLegacyWifiRateInfoToHidl(legacy_result.tx_rate,
2663 &hidl_result->txRate)) {
2664 return false;
2665 }
2666 if (!convertLegacyWifiRateInfoToHidl(legacy_result.rx_rate,
2667 &hidl_result->rxRate)) {
2668 return false;
2669 }
2670 hidl_result->rtt = legacy_result.rtt;
2671 hidl_result->rttSd = legacy_result.rtt_sd;
2672 hidl_result->rttSpread = legacy_result.rtt_spread;
2673 hidl_result->distanceInMm = legacy_result.distance_mm;
2674 hidl_result->distanceSdInMm = legacy_result.distance_sd_mm;
2675 hidl_result->distanceSpreadInMm = legacy_result.distance_spread_mm;
2676 hidl_result->timeStampInUs = legacy_result.ts;
2677 hidl_result->burstDurationInMs = legacy_result.burst_duration;
2678 hidl_result->negotiatedBurstNum = legacy_result.negotiated_burst_num;
2679 if (legacy_result.LCI &&
2680 !convertLegacyIeToHidl(*legacy_result.LCI, &hidl_result->lci)) {
2681 return false;
2682 }
2683 if (legacy_result.LCR &&
2684 !convertLegacyIeToHidl(*legacy_result.LCR, &hidl_result->lcr)) {
2685 return false;
2686 }
2687 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002688}
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002689
2690bool convertLegacyVectorOfRttResultToHidl(
2691 const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
2692 std::vector<RttResult>* hidl_results) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002693 if (!hidl_results) {
2694 return false;
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002695 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002696 *hidl_results = {};
2697 for (const auto legacy_result : legacy_results) {
2698 RttResult hidl_result;
2699 if (!convertLegacyRttResultToHidl(*legacy_result, &hidl_result)) {
2700 return false;
2701 }
2702 hidl_results->push_back(hidl_result);
2703 }
2704 return true;
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002705}
Roshan Piuse65edb12016-11-22 13:02:01 -08002706} // namespace hidl_struct_util
2707} // namespace implementation
Ahmed ElArabawyf501a982019-07-23 15:02:22 -07002708} // namespace V1_4
Roshan Piuse65edb12016-11-22 13:02:01 -08002709} // namespace wifi
2710} // namespace hardware
2711} // namespace android