blob: df9c9dfd257779d58592319bfdd95d6b89394ee9 [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 {
25namespace V1_0 {
26namespace implementation {
27namespace hidl_struct_util {
28
Roshan Piusf72df2e2016-12-04 10:49:38 -080029IWifiChip::ChipCapabilityMask convertLegacyLoggerFeatureToHidlChipCapability(
30 uint32_t feature) {
31 using HidlChipCaps = IWifiChip::ChipCapabilityMask;
32 switch (feature) {
33 case legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED:
Roshan Piusa2d369d2016-12-15 22:38:00 -080034 return HidlChipCaps::DEBUG_MEMORY_FIRMWARE_DUMP;
Roshan Piusf72df2e2016-12-04 10:49:38 -080035 case legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED:
Roshan Piusa2d369d2016-12-15 22:38:00 -080036 return HidlChipCaps::DEBUG_MEMORY_DRIVER_DUMP;
Roshan Piusf72df2e2016-12-04 10:49:38 -080037 case legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED:
Roshan Piusa2d369d2016-12-15 22:38:00 -080038 return HidlChipCaps::DEBUG_RING_BUFFER_CONNECT_EVENT;
Roshan Piusf72df2e2016-12-04 10:49:38 -080039 case legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED:
Roshan Piusa2d369d2016-12-15 22:38:00 -080040 return HidlChipCaps::DEBUG_RING_BUFFER_POWER_EVENT;
Roshan Piusf72df2e2016-12-04 10:49:38 -080041 case legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED:
Roshan Piusa2d369d2016-12-15 22:38:00 -080042 return HidlChipCaps::DEBUG_RING_BUFFER_WAKELOCK_EVENT;
Roshan Piusf72df2e2016-12-04 10:49:38 -080043 };
44 CHECK(false) << "Unknown legacy feature: " << feature;
45 return {};
46}
47
48IWifiStaIface::StaIfaceCapabilityMask
49convertLegacyLoggerFeatureToHidlStaIfaceCapability(uint32_t feature) {
50 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
51 switch (feature) {
52 case legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED:
Roshan Piusa2d369d2016-12-15 22:38:00 -080053 return HidlStaIfaceCaps::DEBUG_PACKET_FATE;
Roshan Piusf72df2e2016-12-04 10:49:38 -080054 };
55 CHECK(false) << "Unknown legacy feature: " << feature;
56 return {};
57}
58
59IWifiStaIface::StaIfaceCapabilityMask
60convertLegacyFeatureToHidlStaIfaceCapability(uint32_t feature) {
61 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
62 switch (feature) {
63 case WIFI_FEATURE_GSCAN:
64 return HidlStaIfaceCaps::BACKGROUND_SCAN;
65 case WIFI_FEATURE_LINK_LAYER_STATS:
66 return HidlStaIfaceCaps::LINK_LAYER_STATS;
Roshan Piusd4767542016-12-06 10:04:05 -080067 case WIFI_FEATURE_RSSI_MONITOR:
68 return HidlStaIfaceCaps::RSSI_MONITOR;
Roshan Pius26801cb2016-12-13 14:25:45 -080069 case WIFI_FEATURE_CONTROL_ROAMING:
70 return HidlStaIfaceCaps::CONTROL_ROAMING;
71 case WIFI_FEATURE_IE_WHITELIST:
72 return HidlStaIfaceCaps::PROBE_IE_WHITELIST;
73 case WIFI_FEATURE_SCAN_RAND:
74 return HidlStaIfaceCaps::SCAN_RAND;
Roshan Piusa2d369d2016-12-15 22:38:00 -080075 case WIFI_FEATURE_INFRA_5G:
76 return HidlStaIfaceCaps::STA_5G;
77 case WIFI_FEATURE_HOTSPOT:
78 return HidlStaIfaceCaps::HOTSPOT;
79 case WIFI_FEATURE_PNO:
80 return HidlStaIfaceCaps::PNO;
81 case WIFI_FEATURE_TDLS:
82 return HidlStaIfaceCaps::TDLS;
83 case WIFI_FEATURE_TDLS_OFFCHANNEL:
84 return HidlStaIfaceCaps::TDLS_OFFCHANNEL;
Roshan Pius656f8202017-01-17 12:58:05 -080085 case WIFI_FEATURE_CONFIG_NDO:
86 return HidlStaIfaceCaps::ND_OFFLOAD;
Roshan Pius9a9869a2017-01-11 16:42:16 -080087 case WIFI_FEATURE_MKEEP_ALIVE:
88 return HidlStaIfaceCaps::KEEP_ALIVE;
Roshan Piusf72df2e2016-12-04 10:49:38 -080089 };
90 CHECK(false) << "Unknown legacy feature: " << feature;
91 return {};
92}
93
94bool convertLegacyFeaturesToHidlChipCapabilities(
95 uint32_t legacy_logger_feature_set, uint32_t* hidl_caps) {
96 if (!hidl_caps) {
97 return false;
98 }
Roshan Pius590744b2017-03-02 07:24:41 -080099 *hidl_caps = {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800100 using HidlChipCaps = IWifiChip::ChipCapabilityMask;
101 for (const auto feature : {legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED,
102 legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED,
103 legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED,
104 legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED,
105 legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED}) {
106 if (feature & legacy_logger_feature_set) {
107 *hidl_caps |= convertLegacyLoggerFeatureToHidlChipCapability(feature);
108 }
109 }
Roshan Pius203cb032016-12-14 17:41:20 -0800110 // There are no flags for these 3 in the legacy feature set. Adding them to
111 // the set because all the current devices support it.
Roshan Piusa2d369d2016-12-15 22:38:00 -0800112 *hidl_caps |= HidlChipCaps::DEBUG_RING_BUFFER_VENDOR_DATA;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800113 *hidl_caps |= HidlChipCaps::DEBUG_HOST_WAKE_REASON_STATS;
Roshan Pius203cb032016-12-14 17:41:20 -0800114 *hidl_caps |= HidlChipCaps::DEBUG_ERROR_ALERTS;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800115 return true;
116}
117
118WifiDebugRingBufferFlags convertLegacyDebugRingBufferFlagsToHidl(
119 uint32_t flag) {
120 switch (flag) {
121 case WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES:
122 return WifiDebugRingBufferFlags::HAS_BINARY_ENTRIES;
123 case WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES:
124 return WifiDebugRingBufferFlags::HAS_ASCII_ENTRIES;
125 };
126 CHECK(false) << "Unknown legacy flag: " << flag;
127 return {};
128}
129
130bool convertLegacyDebugRingBufferStatusToHidl(
131 const legacy_hal::wifi_ring_buffer_status& legacy_status,
132 WifiDebugRingBufferStatus* hidl_status) {
133 if (!hidl_status) {
134 return false;
135 }
Roshan Pius590744b2017-03-02 07:24:41 -0800136 *hidl_status = {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800137 hidl_status->ringName = reinterpret_cast<const char*>(legacy_status.name);
Roshan Pius88c32722017-02-16 12:43:17 -0800138 hidl_status->flags = 0;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800139 for (const auto flag : {WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES,
140 WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES}) {
141 if (flag & legacy_status.flags) {
142 hidl_status->flags |=
143 static_cast<std::underlying_type<WifiDebugRingBufferFlags>::type>(
144 convertLegacyDebugRingBufferFlagsToHidl(flag));
145 }
146 }
147 hidl_status->ringId = legacy_status.ring_id;
148 hidl_status->sizeInBytes = legacy_status.ring_buffer_byte_size;
149 // Calculate free size of the ring the buffer. We don't need to send the
150 // exact read/write pointers that were there in the legacy HAL interface.
151 if (legacy_status.written_bytes >= legacy_status.read_bytes) {
152 hidl_status->freeSizeInBytes =
153 legacy_status.ring_buffer_byte_size -
154 (legacy_status.written_bytes - legacy_status.read_bytes);
155 } else {
156 hidl_status->freeSizeInBytes =
157 legacy_status.read_bytes - legacy_status.written_bytes;
158 }
159 hidl_status->verboseLevel = legacy_status.verbose_level;
160 return true;
161}
162
163bool convertLegacyVectorOfDebugRingBufferStatusToHidl(
164 const std::vector<legacy_hal::wifi_ring_buffer_status>& legacy_status_vec,
165 std::vector<WifiDebugRingBufferStatus>* hidl_status_vec) {
166 if (!hidl_status_vec) {
167 return false;
168 }
Roshan Pius590744b2017-03-02 07:24:41 -0800169 *hidl_status_vec = {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800170 for (const auto& legacy_status : legacy_status_vec) {
171 WifiDebugRingBufferStatus hidl_status;
172 if (!convertLegacyDebugRingBufferStatusToHidl(legacy_status,
173 &hidl_status)) {
174 return false;
175 }
176 hidl_status_vec->push_back(hidl_status);
177 }
178 return true;
179}
180
181bool convertLegacyWakeReasonStatsToHidl(
182 const legacy_hal::WakeReasonStats& legacy_stats,
183 WifiDebugHostWakeReasonStats* hidl_stats) {
184 if (!hidl_stats) {
185 return false;
186 }
Roshan Pius590744b2017-03-02 07:24:41 -0800187 *hidl_stats = {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800188 hidl_stats->totalCmdEventWakeCnt =
189 legacy_stats.wake_reason_cnt.total_cmd_event_wake;
190 hidl_stats->cmdEventWakeCntPerType = legacy_stats.cmd_event_wake_cnt;
191 hidl_stats->totalDriverFwLocalWakeCnt =
192 legacy_stats.wake_reason_cnt.total_driver_fw_local_wake;
193 hidl_stats->driverFwLocalWakeCntPerType =
194 legacy_stats.driver_fw_local_wake_cnt;
195 hidl_stats->totalRxPacketWakeCnt =
196 legacy_stats.wake_reason_cnt.total_rx_data_wake;
197 hidl_stats->rxPktWakeDetails.rxUnicastCnt =
198 legacy_stats.wake_reason_cnt.rx_wake_details.rx_unicast_cnt;
199 hidl_stats->rxPktWakeDetails.rxMulticastCnt =
200 legacy_stats.wake_reason_cnt.rx_wake_details.rx_multicast_cnt;
201 hidl_stats->rxPktWakeDetails.rxBroadcastCnt =
202 legacy_stats.wake_reason_cnt.rx_wake_details.rx_broadcast_cnt;
203 hidl_stats->rxMulticastPkWakeDetails.ipv4RxMulticastAddrCnt =
204 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
205 .ipv4_rx_multicast_addr_cnt;
206 hidl_stats->rxMulticastPkWakeDetails.ipv6RxMulticastAddrCnt =
207 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
208 .ipv6_rx_multicast_addr_cnt;
209 hidl_stats->rxMulticastPkWakeDetails.otherRxMulticastAddrCnt =
210 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
211 .other_rx_multicast_addr_cnt;
212 hidl_stats->rxIcmpPkWakeDetails.icmpPkt =
213 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp_pkt;
214 hidl_stats->rxIcmpPkWakeDetails.icmp6Pkt =
215 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_pkt;
216 hidl_stats->rxIcmpPkWakeDetails.icmp6Ra =
217 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ra;
218 hidl_stats->rxIcmpPkWakeDetails.icmp6Na =
219 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_na;
220 hidl_stats->rxIcmpPkWakeDetails.icmp6Ns =
221 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ns;
222 return true;
223}
224
225bool convertLegacyFeaturesToHidlStaCapabilities(
226 uint32_t legacy_feature_set,
227 uint32_t legacy_logger_feature_set,
228 uint32_t* hidl_caps) {
229 if (!hidl_caps) {
230 return false;
231 }
Roshan Pius590744b2017-03-02 07:24:41 -0800232 *hidl_caps = {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800233 *hidl_caps = 0;
234 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
235 for (const auto feature : {legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED}) {
236 if (feature & legacy_logger_feature_set) {
237 *hidl_caps |= convertLegacyLoggerFeatureToHidlStaIfaceCapability(feature);
238 }
239 }
Roshan Piusd4767542016-12-06 10:04:05 -0800240 for (const auto feature : {WIFI_FEATURE_GSCAN,
241 WIFI_FEATURE_LINK_LAYER_STATS,
Roshan Pius26801cb2016-12-13 14:25:45 -0800242 WIFI_FEATURE_RSSI_MONITOR,
243 WIFI_FEATURE_CONTROL_ROAMING,
244 WIFI_FEATURE_IE_WHITELIST,
Roshan Piusa2d369d2016-12-15 22:38:00 -0800245 WIFI_FEATURE_SCAN_RAND,
246 WIFI_FEATURE_INFRA_5G,
247 WIFI_FEATURE_HOTSPOT,
248 WIFI_FEATURE_PNO,
249 WIFI_FEATURE_TDLS,
Roshan Pius9a9869a2017-01-11 16:42:16 -0800250 WIFI_FEATURE_TDLS_OFFCHANNEL,
Roshan Pius656f8202017-01-17 12:58:05 -0800251 WIFI_FEATURE_CONFIG_NDO,
Roshan Pius9a9869a2017-01-11 16:42:16 -0800252 WIFI_FEATURE_MKEEP_ALIVE}) {
Roshan Piusf72df2e2016-12-04 10:49:38 -0800253 if (feature & legacy_feature_set) {
254 *hidl_caps |= convertLegacyFeatureToHidlStaIfaceCapability(feature);
255 }
256 }
257 // There is no flag for this one in the legacy feature set. Adding it to the
258 // set because all the current devices support it.
259 *hidl_caps |= HidlStaIfaceCaps::APF;
260 return true;
261}
262
263bool convertLegacyApfCapabilitiesToHidl(
264 const legacy_hal::PacketFilterCapabilities& legacy_caps,
265 StaApfPacketFilterCapabilities* hidl_caps) {
266 if (!hidl_caps) {
267 return false;
268 }
Roshan Pius590744b2017-03-02 07:24:41 -0800269 *hidl_caps = {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800270 hidl_caps->version = legacy_caps.version;
271 hidl_caps->maxLength = legacy_caps.max_len;
272 return true;
273}
274
Roshan Pius881d1f72016-12-05 15:37:00 -0800275uint8_t convertHidlGscanReportEventFlagToLegacy(
276 StaBackgroundScanBucketEventReportSchemeMask hidl_flag) {
277 using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
278 switch (hidl_flag) {
279 case HidlFlag::EACH_SCAN:
280 return REPORT_EVENTS_EACH_SCAN;
281 case HidlFlag::FULL_RESULTS:
282 return REPORT_EVENTS_FULL_RESULTS;
283 case HidlFlag::NO_BATCH:
284 return REPORT_EVENTS_NO_BATCH;
285 };
286 CHECK(false);
287}
288
289StaScanDataFlagMask convertLegacyGscanDataFlagToHidl(uint8_t legacy_flag) {
290 switch (legacy_flag) {
291 case legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED:
292 return StaScanDataFlagMask::INTERRUPTED;
293 };
294 CHECK(false) << "Unknown legacy flag: " << legacy_flag;
295 // To silence the compiler warning about reaching the end of non-void
296 // function.
297 return {};
298}
299
300bool convertLegacyGscanCapabilitiesToHidl(
Roshan Piusf72df2e2016-12-04 10:49:38 -0800301 const legacy_hal::wifi_gscan_capabilities& legacy_caps,
302 StaBackgroundScanCapabilities* hidl_caps) {
303 if (!hidl_caps) {
304 return false;
305 }
Roshan Pius590744b2017-03-02 07:24:41 -0800306 *hidl_caps = {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800307 hidl_caps->maxCacheSize = legacy_caps.max_scan_cache_size;
308 hidl_caps->maxBuckets = legacy_caps.max_scan_buckets;
309 hidl_caps->maxApCachePerScan = legacy_caps.max_ap_cache_per_scan;
310 hidl_caps->maxReportingThreshold = legacy_caps.max_scan_reporting_threshold;
311 return true;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800312}
313
Roshan Pius7f4574d2017-02-22 09:48:03 -0800314legacy_hal::wifi_band convertHidlWifiBandToLegacy(WifiBand band) {
Roshan Pius881d1f72016-12-05 15:37:00 -0800315 switch (band) {
Roshan Pius7f4574d2017-02-22 09:48:03 -0800316 case WifiBand::BAND_UNSPECIFIED:
Roshan Pius881d1f72016-12-05 15:37:00 -0800317 return legacy_hal::WIFI_BAND_UNSPECIFIED;
Roshan Pius7f4574d2017-02-22 09:48:03 -0800318 case WifiBand::BAND_24GHZ:
Roshan Pius881d1f72016-12-05 15:37:00 -0800319 return legacy_hal::WIFI_BAND_BG;
Roshan Pius7f4574d2017-02-22 09:48:03 -0800320 case WifiBand::BAND_5GHZ:
Roshan Pius881d1f72016-12-05 15:37:00 -0800321 return legacy_hal::WIFI_BAND_A;
Roshan Pius7f4574d2017-02-22 09:48:03 -0800322 case WifiBand::BAND_5GHZ_DFS:
Roshan Pius881d1f72016-12-05 15:37:00 -0800323 return legacy_hal::WIFI_BAND_A_DFS;
Roshan Pius7f4574d2017-02-22 09:48:03 -0800324 case WifiBand::BAND_5GHZ_WITH_DFS:
Roshan Pius881d1f72016-12-05 15:37:00 -0800325 return legacy_hal::WIFI_BAND_A_WITH_DFS;
Roshan Pius7f4574d2017-02-22 09:48:03 -0800326 case WifiBand::BAND_24GHZ_5GHZ:
Roshan Pius881d1f72016-12-05 15:37:00 -0800327 return legacy_hal::WIFI_BAND_ABG;
Roshan Pius7f4574d2017-02-22 09:48:03 -0800328 case WifiBand::BAND_24GHZ_5GHZ_WITH_DFS:
Roshan Pius881d1f72016-12-05 15:37:00 -0800329 return legacy_hal::WIFI_BAND_ABG_WITH_DFS;
330 };
331 CHECK(false);
332}
333
334bool convertHidlGscanParamsToLegacy(
Roshan Piuse65edb12016-11-22 13:02:01 -0800335 const StaBackgroundScanParameters& hidl_scan_params,
336 legacy_hal::wifi_scan_cmd_params* legacy_scan_params) {
337 if (!legacy_scan_params) {
338 return false;
339 }
Roshan Pius590744b2017-03-02 07:24:41 -0800340 *legacy_scan_params = {};
Roshan Piuse65edb12016-11-22 13:02:01 -0800341 legacy_scan_params->base_period = hidl_scan_params.basePeriodInMs;
342 legacy_scan_params->max_ap_per_scan = hidl_scan_params.maxApPerScan;
343 legacy_scan_params->report_threshold_percent =
344 hidl_scan_params.reportThresholdPercent;
345 legacy_scan_params->report_threshold_num_scans =
346 hidl_scan_params.reportThresholdNumScans;
Roshan Piuse65edb12016-11-22 13:02:01 -0800347 if (hidl_scan_params.buckets.size() > MAX_BUCKETS) {
348 return false;
349 }
350 legacy_scan_params->num_buckets = hidl_scan_params.buckets.size();
351 for (uint32_t bucket_idx = 0; bucket_idx < hidl_scan_params.buckets.size();
352 bucket_idx++) {
353 const StaBackgroundScanBucketParameters& hidl_bucket_spec =
354 hidl_scan_params.buckets[bucket_idx];
355 legacy_hal::wifi_scan_bucket_spec& legacy_bucket_spec =
356 legacy_scan_params->buckets[bucket_idx];
Roshan Pius4cf40592017-03-07 11:17:08 -0800357 if (hidl_bucket_spec.bucketIdx >= MAX_BUCKETS) {
358 return false;
359 }
360 legacy_bucket_spec.bucket = hidl_bucket_spec.bucketIdx;
Roshan Piuse65edb12016-11-22 13:02:01 -0800361 legacy_bucket_spec.band =
Roshan Pius208e46b2017-03-01 19:31:14 -0800362 convertHidlWifiBandToLegacy(hidl_bucket_spec.band);
Roshan Piuse65edb12016-11-22 13:02:01 -0800363 legacy_bucket_spec.period = hidl_bucket_spec.periodInMs;
364 legacy_bucket_spec.max_period = hidl_bucket_spec.exponentialMaxPeriodInMs;
365 legacy_bucket_spec.base = hidl_bucket_spec.exponentialBase;
366 legacy_bucket_spec.step_count = hidl_bucket_spec.exponentialStepCount;
367 legacy_bucket_spec.report_events = 0;
368 using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
369 for (const auto flag :
370 {HidlFlag::EACH_SCAN, HidlFlag::FULL_RESULTS, HidlFlag::NO_BATCH}) {
371 if (hidl_bucket_spec.eventReportScheme &
372 static_cast<std::underlying_type<HidlFlag>::type>(flag)) {
373 legacy_bucket_spec.report_events |=
Roshan Pius881d1f72016-12-05 15:37:00 -0800374 convertHidlGscanReportEventFlagToLegacy(flag);
Roshan Piuse65edb12016-11-22 13:02:01 -0800375 }
376 }
Roshan Piuse65edb12016-11-22 13:02:01 -0800377 if (hidl_bucket_spec.frequencies.size() > MAX_CHANNELS) {
378 return false;
379 }
380 legacy_bucket_spec.num_channels = hidl_bucket_spec.frequencies.size();
381 for (uint32_t freq_idx = 0; freq_idx < hidl_bucket_spec.frequencies.size();
382 freq_idx++) {
383 legacy_bucket_spec.channels[freq_idx].channel =
384 hidl_bucket_spec.frequencies[freq_idx];
385 }
386 }
387 return true;
388}
389
Roshan Pius3fae9c82016-12-02 14:49:41 -0800390bool convertLegacyIeToHidl(
391 const legacy_hal::wifi_information_element& legacy_ie,
392 WifiInformationElement* hidl_ie) {
393 if (!hidl_ie) {
394 return false;
395 }
Roshan Pius590744b2017-03-02 07:24:41 -0800396 *hidl_ie = {};
Roshan Pius3fae9c82016-12-02 14:49:41 -0800397 hidl_ie->id = legacy_ie.id;
398 hidl_ie->data =
399 std::vector<uint8_t>(legacy_ie.data, legacy_ie.data + legacy_ie.len);
400 return true;
401}
402
Roshan Piuse65edb12016-11-22 13:02:01 -0800403bool convertLegacyIeBlobToHidl(const uint8_t* ie_blob,
404 uint32_t ie_blob_len,
405 std::vector<WifiInformationElement>* hidl_ies) {
406 if (!ie_blob || !hidl_ies) {
407 return false;
408 }
Roshan Pius590744b2017-03-02 07:24:41 -0800409 *hidl_ies = {};
Roshan Piuse65edb12016-11-22 13:02:01 -0800410 const uint8_t* ies_begin = ie_blob;
411 const uint8_t* ies_end = ie_blob + ie_blob_len;
412 const uint8_t* next_ie = ies_begin;
413 using wifi_ie = legacy_hal::wifi_information_element;
414 constexpr size_t kIeHeaderLen = sizeof(wifi_ie);
415 // Each IE should atleast have the header (i.e |id| & |len| fields).
416 while (next_ie + kIeHeaderLen <= ies_end) {
417 const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie));
418 uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len;
419 if (next_ie + curr_ie_len > ies_end) {
420 return false;
421 }
422 WifiInformationElement hidl_ie;
Roshan Pius3fae9c82016-12-02 14:49:41 -0800423 if (!convertLegacyIeToHidl(legacy_ie, &hidl_ie)) {
424 return false;
425 }
Roshan Piuse65edb12016-11-22 13:02:01 -0800426 hidl_ies->push_back(std::move(hidl_ie));
427 next_ie += curr_ie_len;
428 }
429 // Ensure that the blob has been fully consumed.
430 return (next_ie == ies_end);
431}
432
Roshan Pius881d1f72016-12-05 15:37:00 -0800433bool convertLegacyGscanResultToHidl(
Roshan Piuse65edb12016-11-22 13:02:01 -0800434 const legacy_hal::wifi_scan_result& legacy_scan_result,
435 bool has_ie_data,
436 StaScanResult* hidl_scan_result) {
437 if (!hidl_scan_result) {
438 return false;
439 }
Roshan Pius590744b2017-03-02 07:24:41 -0800440 *hidl_scan_result = {};
Roshan Piuse65edb12016-11-22 13:02:01 -0800441 hidl_scan_result->timeStampInUs = legacy_scan_result.ts;
442 hidl_scan_result->ssid = std::vector<uint8_t>(
443 legacy_scan_result.ssid,
Roshan Pius208e46b2017-03-01 19:31:14 -0800444 legacy_scan_result.ssid + strlen(legacy_scan_result.ssid));
Roshan Piuse65edb12016-11-22 13:02:01 -0800445 memcpy(hidl_scan_result->bssid.data(),
446 legacy_scan_result.bssid,
447 hidl_scan_result->bssid.size());
448 hidl_scan_result->frequency = legacy_scan_result.channel;
449 hidl_scan_result->rssi = legacy_scan_result.rssi;
450 hidl_scan_result->beaconPeriodInMs = legacy_scan_result.beacon_period;
451 hidl_scan_result->capability = legacy_scan_result.capability;
452 if (has_ie_data) {
453 std::vector<WifiInformationElement> ies;
454 if (!convertLegacyIeBlobToHidl(
455 reinterpret_cast<const uint8_t*>(legacy_scan_result.ie_data),
456 legacy_scan_result.ie_length,
457 &ies)) {
458 return false;
459 }
460 hidl_scan_result->informationElements = std::move(ies);
461 }
462 return true;
463}
464
Roshan Pius881d1f72016-12-05 15:37:00 -0800465bool convertLegacyCachedGscanResultsToHidl(
Roshan Piuse65edb12016-11-22 13:02:01 -0800466 const legacy_hal::wifi_cached_scan_results& legacy_cached_scan_result,
467 StaScanData* hidl_scan_data) {
468 if (!hidl_scan_data) {
469 return false;
470 }
Roshan Pius590744b2017-03-02 07:24:41 -0800471 *hidl_scan_data = {};
Roshan Pius88c32722017-02-16 12:43:17 -0800472 hidl_scan_data->flags = 0;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800473 for (const auto flag : {legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED}) {
474 if (legacy_cached_scan_result.flags & flag) {
475 hidl_scan_data->flags |=
476 static_cast<std::underlying_type<StaScanDataFlagMask>::type>(
Roshan Pius881d1f72016-12-05 15:37:00 -0800477 convertLegacyGscanDataFlagToHidl(flag));
Roshan Pius32d0ca92016-12-02 11:21:19 -0800478 }
479 }
Roshan Piuse65edb12016-11-22 13:02:01 -0800480 hidl_scan_data->bucketsScanned = legacy_cached_scan_result.buckets_scanned;
481
482 CHECK(legacy_cached_scan_result.num_results >= 0 &&
483 legacy_cached_scan_result.num_results <= MAX_AP_CACHE_PER_SCAN);
484 std::vector<StaScanResult> hidl_scan_results;
485 for (int32_t result_idx = 0;
486 result_idx < legacy_cached_scan_result.num_results;
487 result_idx++) {
488 StaScanResult hidl_scan_result;
Roshan Pius881d1f72016-12-05 15:37:00 -0800489 if (!convertLegacyGscanResultToHidl(
Roshan Piuse65edb12016-11-22 13:02:01 -0800490 legacy_cached_scan_result.results[result_idx],
491 false,
492 &hidl_scan_result)) {
493 return false;
494 }
495 hidl_scan_results.push_back(hidl_scan_result);
496 }
497 hidl_scan_data->results = std::move(hidl_scan_results);
498 return true;
499}
500
Roshan Pius881d1f72016-12-05 15:37:00 -0800501bool convertLegacyVectorOfCachedGscanResultsToHidl(
Roshan Piuse65edb12016-11-22 13:02:01 -0800502 const std::vector<legacy_hal::wifi_cached_scan_results>&
503 legacy_cached_scan_results,
504 std::vector<StaScanData>* hidl_scan_datas) {
505 if (!hidl_scan_datas) {
506 return false;
507 }
Roshan Pius590744b2017-03-02 07:24:41 -0800508 *hidl_scan_datas = {};
Roshan Piuse65edb12016-11-22 13:02:01 -0800509 for (const auto& legacy_cached_scan_result : legacy_cached_scan_results) {
510 StaScanData hidl_scan_data;
Roshan Pius881d1f72016-12-05 15:37:00 -0800511 if (!convertLegacyCachedGscanResultsToHidl(legacy_cached_scan_result,
512 &hidl_scan_data)) {
Roshan Piuse65edb12016-11-22 13:02:01 -0800513 return false;
514 }
515 hidl_scan_datas->push_back(hidl_scan_data);
516 }
517 return true;
518}
519
Roshan Pius32d0ca92016-12-02 11:21:19 -0800520WifiDebugTxPacketFate convertLegacyDebugTxPacketFateToHidl(
521 legacy_hal::wifi_tx_packet_fate fate) {
522 switch (fate) {
523 case legacy_hal::TX_PKT_FATE_ACKED:
524 return WifiDebugTxPacketFate::ACKED;
525 case legacy_hal::TX_PKT_FATE_SENT:
526 return WifiDebugTxPacketFate::SENT;
527 case legacy_hal::TX_PKT_FATE_FW_QUEUED:
528 return WifiDebugTxPacketFate::FW_QUEUED;
529 case legacy_hal::TX_PKT_FATE_FW_DROP_INVALID:
530 return WifiDebugTxPacketFate::FW_DROP_INVALID;
531 case legacy_hal::TX_PKT_FATE_FW_DROP_NOBUFS:
532 return WifiDebugTxPacketFate::FW_DROP_NOBUFS;
533 case legacy_hal::TX_PKT_FATE_FW_DROP_OTHER:
534 return WifiDebugTxPacketFate::FW_DROP_OTHER;
535 case legacy_hal::TX_PKT_FATE_DRV_QUEUED:
536 return WifiDebugTxPacketFate::DRV_QUEUED;
537 case legacy_hal::TX_PKT_FATE_DRV_DROP_INVALID:
538 return WifiDebugTxPacketFate::DRV_DROP_INVALID;
539 case legacy_hal::TX_PKT_FATE_DRV_DROP_NOBUFS:
540 return WifiDebugTxPacketFate::DRV_DROP_NOBUFS;
541 case legacy_hal::TX_PKT_FATE_DRV_DROP_OTHER:
542 return WifiDebugTxPacketFate::DRV_DROP_OTHER;
543 };
Roshan Pius3fae9c82016-12-02 14:49:41 -0800544 CHECK(false) << "Unknown legacy fate type: " << fate;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800545}
546
547WifiDebugRxPacketFate convertLegacyDebugRxPacketFateToHidl(
548 legacy_hal::wifi_rx_packet_fate fate) {
549 switch (fate) {
550 case legacy_hal::RX_PKT_FATE_SUCCESS:
551 return WifiDebugRxPacketFate::SUCCESS;
552 case legacy_hal::RX_PKT_FATE_FW_QUEUED:
553 return WifiDebugRxPacketFate::FW_QUEUED;
554 case legacy_hal::RX_PKT_FATE_FW_DROP_FILTER:
555 return WifiDebugRxPacketFate::FW_DROP_FILTER;
556 case legacy_hal::RX_PKT_FATE_FW_DROP_INVALID:
557 return WifiDebugRxPacketFate::FW_DROP_INVALID;
558 case legacy_hal::RX_PKT_FATE_FW_DROP_NOBUFS:
559 return WifiDebugRxPacketFate::FW_DROP_NOBUFS;
560 case legacy_hal::RX_PKT_FATE_FW_DROP_OTHER:
561 return WifiDebugRxPacketFate::FW_DROP_OTHER;
562 case legacy_hal::RX_PKT_FATE_DRV_QUEUED:
563 return WifiDebugRxPacketFate::DRV_QUEUED;
564 case legacy_hal::RX_PKT_FATE_DRV_DROP_FILTER:
565 return WifiDebugRxPacketFate::DRV_DROP_FILTER;
566 case legacy_hal::RX_PKT_FATE_DRV_DROP_INVALID:
567 return WifiDebugRxPacketFate::DRV_DROP_INVALID;
568 case legacy_hal::RX_PKT_FATE_DRV_DROP_NOBUFS:
569 return WifiDebugRxPacketFate::DRV_DROP_NOBUFS;
570 case legacy_hal::RX_PKT_FATE_DRV_DROP_OTHER:
571 return WifiDebugRxPacketFate::DRV_DROP_OTHER;
572 };
Roshan Pius3fae9c82016-12-02 14:49:41 -0800573 CHECK(false) << "Unknown legacy fate type: " << fate;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800574}
575
576WifiDebugPacketFateFrameType convertLegacyDebugPacketFateFrameTypeToHidl(
577 legacy_hal::frame_type type) {
578 switch (type) {
579 case legacy_hal::FRAME_TYPE_UNKNOWN:
580 return WifiDebugPacketFateFrameType::UNKNOWN;
581 case legacy_hal::FRAME_TYPE_ETHERNET_II:
582 return WifiDebugPacketFateFrameType::ETHERNET_II;
583 case legacy_hal::FRAME_TYPE_80211_MGMT:
584 return WifiDebugPacketFateFrameType::MGMT_80211;
585 };
Roshan Pius3fae9c82016-12-02 14:49:41 -0800586 CHECK(false) << "Unknown legacy frame type: " << type;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800587}
588
589bool convertLegacyDebugPacketFateFrameToHidl(
590 const legacy_hal::frame_info& legacy_frame,
591 WifiDebugPacketFateFrameInfo* hidl_frame) {
592 if (!hidl_frame) {
593 return false;
594 }
Roshan Pius590744b2017-03-02 07:24:41 -0800595 *hidl_frame = {};
Roshan Pius32d0ca92016-12-02 11:21:19 -0800596 hidl_frame->frameType =
597 convertLegacyDebugPacketFateFrameTypeToHidl(legacy_frame.payload_type);
598 hidl_frame->frameLen = legacy_frame.frame_len;
599 hidl_frame->driverTimestampUsec = legacy_frame.driver_timestamp_usec;
600 hidl_frame->firmwareTimestampUsec = legacy_frame.firmware_timestamp_usec;
601 const uint8_t* frame_begin = reinterpret_cast<const uint8_t*>(
602 legacy_frame.frame_content.ethernet_ii_bytes);
603 hidl_frame->frameContent =
604 std::vector<uint8_t>(frame_begin, frame_begin + legacy_frame.frame_len);
605 return true;
606}
607
608bool convertLegacyDebugTxPacketFateToHidl(
609 const legacy_hal::wifi_tx_report& legacy_fate,
610 WifiDebugTxPacketFateReport* hidl_fate) {
611 if (!hidl_fate) {
612 return false;
613 }
Roshan Pius590744b2017-03-02 07:24:41 -0800614 *hidl_fate = {};
Roshan Pius32d0ca92016-12-02 11:21:19 -0800615 hidl_fate->fate = convertLegacyDebugTxPacketFateToHidl(legacy_fate.fate);
616 return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
617 &hidl_fate->frameInfo);
618}
619
Roshan Piusf72df2e2016-12-04 10:49:38 -0800620bool convertLegacyVectorOfDebugTxPacketFateToHidl(
621 const std::vector<legacy_hal::wifi_tx_report>& legacy_fates,
622 std::vector<WifiDebugTxPacketFateReport>* hidl_fates) {
623 if (!hidl_fates) {
624 return false;
625 }
Roshan Pius590744b2017-03-02 07:24:41 -0800626 *hidl_fates = {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800627 for (const auto& legacy_fate : legacy_fates) {
628 WifiDebugTxPacketFateReport hidl_fate;
629 if (!convertLegacyDebugTxPacketFateToHidl(legacy_fate, &hidl_fate)) {
630 return false;
631 }
632 hidl_fates->push_back(hidl_fate);
633 }
634 return true;
635}
636
Roshan Pius32d0ca92016-12-02 11:21:19 -0800637bool convertLegacyDebugRxPacketFateToHidl(
638 const legacy_hal::wifi_rx_report& legacy_fate,
639 WifiDebugRxPacketFateReport* hidl_fate) {
640 if (!hidl_fate) {
641 return false;
642 }
Roshan Pius590744b2017-03-02 07:24:41 -0800643 *hidl_fate = {};
Roshan Pius32d0ca92016-12-02 11:21:19 -0800644 hidl_fate->fate = convertLegacyDebugRxPacketFateToHidl(legacy_fate.fate);
645 return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
646 &hidl_fate->frameInfo);
647}
648
Roshan Piusf72df2e2016-12-04 10:49:38 -0800649bool convertLegacyVectorOfDebugRxPacketFateToHidl(
650 const std::vector<legacy_hal::wifi_rx_report>& legacy_fates,
651 std::vector<WifiDebugRxPacketFateReport>* hidl_fates) {
652 if (!hidl_fates) {
653 return false;
654 }
Roshan Pius590744b2017-03-02 07:24:41 -0800655 *hidl_fates = {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800656 for (const auto& legacy_fate : legacy_fates) {
657 WifiDebugRxPacketFateReport hidl_fate;
658 if (!convertLegacyDebugRxPacketFateToHidl(legacy_fate, &hidl_fate)) {
659 return false;
660 }
661 hidl_fates->push_back(hidl_fate);
662 }
663 return true;
664}
665
Roshan Piuse65edb12016-11-22 13:02:01 -0800666bool convertLegacyLinkLayerStatsToHidl(
667 const legacy_hal::LinkLayerStats& legacy_stats,
668 StaLinkLayerStats* hidl_stats) {
669 if (!hidl_stats) {
670 return false;
671 }
Roshan Pius590744b2017-03-02 07:24:41 -0800672 *hidl_stats = {};
Roshan Piuse65edb12016-11-22 13:02:01 -0800673 // iface legacy_stats conversion.
674 hidl_stats->iface.beaconRx = legacy_stats.iface.beacon_rx;
675 hidl_stats->iface.avgRssiMgmt = legacy_stats.iface.rssi_mgmt;
676 hidl_stats->iface.wmeBePktStats.rxMpdu =
677 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu;
678 hidl_stats->iface.wmeBePktStats.txMpdu =
679 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu;
680 hidl_stats->iface.wmeBePktStats.lostMpdu =
681 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost;
682 hidl_stats->iface.wmeBePktStats.retries =
683 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries;
684 hidl_stats->iface.wmeBkPktStats.rxMpdu =
685 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu;
686 hidl_stats->iface.wmeBkPktStats.txMpdu =
687 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu;
688 hidl_stats->iface.wmeBkPktStats.lostMpdu =
689 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost;
690 hidl_stats->iface.wmeBkPktStats.retries =
691 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries;
692 hidl_stats->iface.wmeViPktStats.rxMpdu =
693 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu;
694 hidl_stats->iface.wmeViPktStats.txMpdu =
695 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu;
696 hidl_stats->iface.wmeViPktStats.lostMpdu =
697 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost;
698 hidl_stats->iface.wmeViPktStats.retries =
699 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries;
700 hidl_stats->iface.wmeVoPktStats.rxMpdu =
701 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu;
702 hidl_stats->iface.wmeVoPktStats.txMpdu =
703 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu;
704 hidl_stats->iface.wmeVoPktStats.lostMpdu =
705 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost;
706 hidl_stats->iface.wmeVoPktStats.retries =
707 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries;
708 // radio legacy_stats conversion.
Roshan Piuse42ace22017-03-13 10:44:20 -0700709 std::vector<StaLinkLayerRadioStats> hidl_radios_stats;
710 for (const auto& legacy_radio_stats : legacy_stats.radios) {
711 StaLinkLayerRadioStats hidl_radio_stats;
712 hidl_radio_stats.onTimeInMs = legacy_radio_stats.stats.on_time;
713 hidl_radio_stats.txTimeInMs = legacy_radio_stats.stats.tx_time;
714 hidl_radio_stats.rxTimeInMs = legacy_radio_stats.stats.rx_time;
715 hidl_radio_stats.onTimeInMsForScan = legacy_radio_stats.stats.on_time_scan;
716 hidl_radio_stats.txTimeInMsPerLevel = legacy_radio_stats.tx_time_per_levels;
717 hidl_radios_stats.push_back(hidl_radio_stats);
718 }
719 hidl_stats->radios = hidl_radios_stats;
Roshan Piuse65edb12016-11-22 13:02:01 -0800720 // Timestamp in the HAL wrapper here since it's not provided in the legacy
721 // HAL API.
722 hidl_stats->timeStampInMs = uptimeMillis();
723 return true;
724}
Roshan Piusf5f51fd2016-12-01 13:54:24 -0800725
Roshan Pius26801cb2016-12-13 14:25:45 -0800726bool convertLegacyRoamingCapabilitiesToHidl(
727 const legacy_hal::wifi_roaming_capabilities& legacy_caps,
728 StaRoamingCapabilities* hidl_caps) {
729 if (!hidl_caps) {
730 return false;
731 }
Roshan Pius590744b2017-03-02 07:24:41 -0800732 *hidl_caps = {};
Roshan Pius26801cb2016-12-13 14:25:45 -0800733 hidl_caps->maxBlacklistSize = legacy_caps.max_blacklist_size;
734 hidl_caps->maxWhitelistSize = legacy_caps.max_whitelist_size;
735 return true;
736}
737
738bool convertHidlRoamingConfigToLegacy(
739 const StaRoamingConfig& hidl_config,
740 legacy_hal::wifi_roaming_config* legacy_config) {
741 if (!legacy_config) {
742 return false;
743 }
Roshan Pius590744b2017-03-02 07:24:41 -0800744 *legacy_config = {};
Roshan Pius26801cb2016-12-13 14:25:45 -0800745 if (hidl_config.bssidBlacklist.size() > MAX_BLACKLIST_BSSID ||
746 hidl_config.ssidWhitelist.size() > MAX_WHITELIST_SSID) {
747 return false;
748 }
749 legacy_config->num_blacklist_bssid = hidl_config.bssidBlacklist.size();
750 uint32_t i = 0;
751 for (const auto& bssid : hidl_config.bssidBlacklist) {
752 CHECK(bssid.size() == sizeof(legacy_hal::mac_addr));
753 memcpy(legacy_config->blacklist_bssid[i++], bssid.data(), bssid.size());
754 }
755 legacy_config->num_whitelist_ssid = hidl_config.ssidWhitelist.size();
756 i = 0;
757 for (const auto& ssid : hidl_config.ssidWhitelist) {
758 CHECK(ssid.size() <= sizeof(legacy_hal::ssid_t::ssid_str));
759 legacy_config->whitelist_ssid[i].length = ssid.size();
760 memcpy(legacy_config->whitelist_ssid[i].ssid_str, ssid.data(), ssid.size());
761 i++;
762 }
763 return true;
764}
765
766legacy_hal::fw_roaming_state_t convertHidlRoamingStateToLegacy(
767 StaRoamingState state) {
768 switch (state) {
769 case StaRoamingState::ENABLED:
770 return legacy_hal::ROAMING_ENABLE;
771 case StaRoamingState::DISABLED:
772 return legacy_hal::ROAMING_DISABLE;
773 };
774 CHECK(false);
775}
776
Etan Cohen67d378d2017-04-03 16:10:54 -0700777legacy_hal::NanMatchAlg convertHidlNanMatchAlgToLegacy(NanMatchAlg type) {
778 switch (type) {
779 case NanMatchAlg::MATCH_ONCE:
780 return legacy_hal::NAN_MATCH_ALG_MATCH_ONCE;
781 case NanMatchAlg::MATCH_CONTINUOUS:
782 return legacy_hal::NAN_MATCH_ALG_MATCH_CONTINUOUS;
783 case NanMatchAlg::MATCH_NEVER:
784 return legacy_hal::NAN_MATCH_ALG_MATCH_NEVER;
785 }
786 CHECK(false);
787}
788
789legacy_hal::NanPublishType convertHidlNanPublishTypeToLegacy(NanPublishType type) {
790 switch (type) {
791 case NanPublishType::UNSOLICITED:
792 return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED;
793 case NanPublishType::SOLICITED:
794 return legacy_hal::NAN_PUBLISH_TYPE_SOLICITED;
795 case NanPublishType::UNSOLICITED_SOLICITED:
796 return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
797 }
798 CHECK(false);
799}
800
801legacy_hal::NanTxType convertHidlNanTxTypeToLegacy(NanTxType type) {
802 switch (type) {
803 case NanTxType::BROADCAST:
804 return legacy_hal::NAN_TX_TYPE_BROADCAST;
805 case NanTxType::UNICAST:
806 return legacy_hal::NAN_TX_TYPE_UNICAST;
807 }
808 CHECK(false);
809}
810
811legacy_hal::NanSubscribeType convertHidlNanSubscribeTypeToLegacy(NanSubscribeType type) {
812 switch (type) {
813 case NanSubscribeType::PASSIVE:
814 return legacy_hal::NAN_SUBSCRIBE_TYPE_PASSIVE;
815 case NanSubscribeType::ACTIVE:
816 return legacy_hal::NAN_SUBSCRIBE_TYPE_ACTIVE;
817 }
818 CHECK(false);
819}
820
821legacy_hal::NanSRFType convertHidlNanSrfTypeToLegacy(NanSrfType type) {
822 switch (type) {
823 case NanSrfType::BLOOM_FILTER:
824 return legacy_hal::NAN_SRF_ATTR_BLOOM_FILTER;
825 case NanSrfType::PARTIAL_MAC_ADDR:
826 return legacy_hal::NAN_SRF_ATTR_PARTIAL_MAC_ADDR;
827 }
828 CHECK(false);
829}
830
831legacy_hal::NanDataPathChannelCfg convertHidlNanDataPathChannelCfgToLegacy(
832 NanDataPathChannelCfg type) {
833 switch (type) {
834 case NanDataPathChannelCfg::CHANNEL_NOT_REQUESTED:
835 return legacy_hal::NAN_DP_CHANNEL_NOT_REQUESTED;
836 case NanDataPathChannelCfg::REQUEST_CHANNEL_SETUP:
837 return legacy_hal::NAN_DP_REQUEST_CHANNEL_SETUP;
838 case NanDataPathChannelCfg::FORCE_CHANNEL_SETUP:
839 return legacy_hal::NAN_DP_FORCE_CHANNEL_SETUP;
840 }
841 CHECK(false);
842}
843
Roshan Piusf5f51fd2016-12-01 13:54:24 -0800844NanStatusType convertLegacyNanStatusTypeToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800845 legacy_hal::NanStatusType type) {
Etan Cohen67d378d2017-04-03 16:10:54 -0700846 switch (type) {
847 case legacy_hal::NAN_STATUS_SUCCESS:
848 return NanStatusType::SUCCESS;
849 case legacy_hal::NAN_STATUS_INTERNAL_FAILURE:
850 return NanStatusType::INTERNAL_FAILURE;
851 case legacy_hal::NAN_STATUS_PROTOCOL_FAILURE:
852 return NanStatusType::PROTOCOL_FAILURE;
853 case legacy_hal::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID:
854 return NanStatusType::INVALID_SESSION_ID;
855 case legacy_hal::NAN_STATUS_NO_RESOURCE_AVAILABLE:
856 return NanStatusType::NO_RESOURCES_AVAILABLE;
857 case legacy_hal::NAN_STATUS_INVALID_PARAM:
858 return NanStatusType::INVALID_ARGS;
859 case legacy_hal::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID:
860 return NanStatusType::INVALID_PEER_ID;
861 case legacy_hal::NAN_STATUS_INVALID_NDP_ID:
862 return NanStatusType::INVALID_NDP_ID;
863 case legacy_hal::NAN_STATUS_NAN_NOT_ALLOWED:
864 return NanStatusType::NAN_NOT_ALLOWED;
865 case legacy_hal::NAN_STATUS_NO_OTA_ACK:
866 return NanStatusType::NO_OTA_ACK;
867 case legacy_hal::NAN_STATUS_ALREADY_ENABLED:
868 return NanStatusType::ALREADY_ENABLED;
869 case legacy_hal::NAN_STATUS_FOLLOWUP_QUEUE_FULL:
870 return NanStatusType::FOLLOWUP_TX_QUEUE_FULL;
871 case legacy_hal::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED:
872 return NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED;
873 }
874 CHECK(false);
Roshan Piusf5f51fd2016-12-01 13:54:24 -0800875}
876
877bool convertHidlNanEnableRequestToLegacy(
878 const NanEnableRequest& hidl_request,
879 legacy_hal::NanEnableRequest* legacy_request) {
880 if (!legacy_request) {
Etan Cohen4bbc2092017-01-30 13:28:37 -0800881 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: null legacy_request";
Roshan Piusf5f51fd2016-12-01 13:54:24 -0800882 return false;
883 }
Roshan Pius590744b2017-03-02 07:24:41 -0800884 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800885
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800886 legacy_request->config_2dot4g_support = 1;
887 legacy_request->support_2dot4g_val = hidl_request.operateInBand[
888 (size_t) NanBandIndex::NAN_BAND_24GHZ];
889 legacy_request->config_support_5g = 1;
890 legacy_request->support_5g_val = hidl_request.operateInBand[(size_t) NanBandIndex::NAN_BAND_5GHZ];
Etan Cohen4bbc2092017-01-30 13:28:37 -0800891 legacy_request->config_hop_count_limit = 1;
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800892 legacy_request->hop_count_limit_val = hidl_request.hopCountMax;
893 legacy_request->master_pref = hidl_request.configParams.masterPref;
894 legacy_request->discovery_indication_cfg = 0;
895 legacy_request->discovery_indication_cfg |=
896 hidl_request.configParams.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
897 legacy_request->discovery_indication_cfg |=
898 hidl_request.configParams.disableStartedClusterIndication ? 0x2 : 0x0;
899 legacy_request->discovery_indication_cfg |=
900 hidl_request.configParams.disableJoinedClusterIndication ? 0x4 : 0x0;
901 legacy_request->config_sid_beacon = 1;
Etan Cohen44983ae2017-02-09 09:16:25 -0800902 if (hidl_request.configParams.numberOfPublishServiceIdsInBeacon > 127) {
903 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: numberOfPublishServiceIdsInBeacon > 127";
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800904 return false;
905 }
Etan Cohen44983ae2017-02-09 09:16:25 -0800906 legacy_request->sid_beacon_val =
907 (hidl_request.configParams.includePublishServiceIdsInBeacon ? 0x1 : 0x0)
908 | (hidl_request.configParams.numberOfPublishServiceIdsInBeacon << 1);
Etan Cohenb9b71ce2017-02-09 12:55:23 -0800909 // TODO: b/35195516 connect SubscribeServiceIds to legacy HAL once implemented
Etan Cohen4bbc2092017-01-30 13:28:37 -0800910 legacy_request->config_rssi_window_size = 1;
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800911 legacy_request->rssi_window_size_val = hidl_request.configParams.rssiWindowSize;
912 legacy_request->config_disc_mac_addr_randomization = 1;
913 legacy_request->disc_mac_addr_rand_interval_sec =
914 hidl_request.configParams.macAddressRandomizationIntervalSec;
Etan Cohen4bbc2092017-01-30 13:28:37 -0800915 legacy_request->config_2dot4g_rssi_close = 1;
916 if (hidl_request.configParams.bandSpecificConfig.size() != 2) {
917 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: bandSpecificConfig.size() != 2";
918 return false;
919 }
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800920 legacy_request->rssi_close_2dot4g_val =
921 hidl_request.configParams.bandSpecificConfig[
922 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiClose;
Etan Cohen4bbc2092017-01-30 13:28:37 -0800923 legacy_request->config_2dot4g_rssi_middle = 1;
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800924 legacy_request->rssi_middle_2dot4g_val =
925 hidl_request.configParams.bandSpecificConfig[
926 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiMiddle;
Etan Cohen4bbc2092017-01-30 13:28:37 -0800927 legacy_request->config_2dot4g_rssi_proximity = 1;
Roshan Piusf5f51fd2016-12-01 13:54:24 -0800928 legacy_request->rssi_proximity_2dot4g_val =
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800929 hidl_request.configParams.bandSpecificConfig[
Etan Cohen44983ae2017-02-09 09:16:25 -0800930 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiCloseProximity;
Etan Cohen4bbc2092017-01-30 13:28:37 -0800931 legacy_request->config_scan_params = 1;
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800932 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
933 hidl_request.configParams.bandSpecificConfig[
934 (size_t) NanBandIndex::NAN_BAND_24GHZ].dwellTimeMs;
935 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
936 hidl_request.configParams.bandSpecificConfig[
937 (size_t) NanBandIndex::NAN_BAND_24GHZ].scanPeriodSec;
938 legacy_request->config_dw.config_2dot4g_dw_band = hidl_request.configParams
939 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].validDiscoveryWindowIntervalVal;
940 legacy_request->config_dw.dw_2dot4g_interval_val = hidl_request.configParams
941 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].discoveryWindowIntervalVal;
Etan Cohen4bbc2092017-01-30 13:28:37 -0800942 legacy_request->config_5g_rssi_close = 1;
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800943 legacy_request->rssi_close_5g_val =
944 hidl_request.configParams.bandSpecificConfig[
945 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiClose;
Etan Cohen4bbc2092017-01-30 13:28:37 -0800946 legacy_request->config_5g_rssi_middle = 1;
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800947 legacy_request->rssi_middle_5g_val =
948 hidl_request.configParams.bandSpecificConfig[
949 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiMiddle;
Etan Cohen4bbc2092017-01-30 13:28:37 -0800950 legacy_request->config_5g_rssi_close_proximity = 1;
Roshan Piusf5f51fd2016-12-01 13:54:24 -0800951 legacy_request->rssi_close_proximity_5g_val =
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800952 hidl_request.configParams.bandSpecificConfig[
Etan Cohen44983ae2017-02-09 09:16:25 -0800953 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiCloseProximity;
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800954 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
955 hidl_request.configParams.bandSpecificConfig[
956 (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
957 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
958 hidl_request.configParams.bandSpecificConfig[
959 (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
960 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
961 hidl_request.configParams.bandSpecificConfig[
962 (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
963 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
964 hidl_request.configParams.bandSpecificConfig[
965 (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
966 legacy_request->config_dw.config_5g_dw_band = hidl_request.configParams
967 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].validDiscoveryWindowIntervalVal;
968 legacy_request->config_dw.dw_5g_interval_val = hidl_request.configParams
969 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].discoveryWindowIntervalVal;
970 if (hidl_request.debugConfigs.validClusterIdVals) {
Etan Cohen44983ae2017-02-09 09:16:25 -0800971 legacy_request->cluster_low = hidl_request.debugConfigs.clusterIdBottomRangeVal;
972 legacy_request->cluster_high = hidl_request.debugConfigs.clusterIdTopRangeVal;
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800973 } else { // need 'else' since not configurable in legacy HAL
974 legacy_request->cluster_low = 0x0000;
975 legacy_request->cluster_high = 0xFFFF;
Roshan Piusf5f51fd2016-12-01 13:54:24 -0800976 }
Etan Cohenf01bcaa2016-12-25 09:42:21 -0800977 legacy_request->config_intf_addr = hidl_request.debugConfigs.validIntfAddrVal;
978 memcpy(legacy_request->intf_addr_val, hidl_request.debugConfigs.intfAddrVal.data(), 6);
979 legacy_request->config_oui = hidl_request.debugConfigs.validOuiVal;
980 legacy_request->oui_val = hidl_request.debugConfigs.ouiVal;
981 legacy_request->config_random_factor_force = hidl_request.debugConfigs.validRandomFactorForceVal;
982 legacy_request->random_factor_force_val = hidl_request.debugConfigs.randomFactorForceVal;
983 legacy_request->config_hop_count_force = hidl_request.debugConfigs.validHopCountForceVal;
984 legacy_request->hop_count_force_val = hidl_request.debugConfigs.hopCountForceVal;
985 legacy_request->config_24g_channel = hidl_request.debugConfigs.validDiscoveryChannelVal;
986 legacy_request->channel_24g_val =
987 hidl_request.debugConfigs.discoveryChannelMhzVal[(size_t) NanBandIndex::NAN_BAND_24GHZ];
988 legacy_request->config_5g_channel = hidl_request.debugConfigs.validDiscoveryChannelVal;
989 legacy_request->channel_5g_val = hidl_request.debugConfigs
990 .discoveryChannelMhzVal[(size_t) NanBandIndex::NAN_BAND_5GHZ];
991 legacy_request->config_2dot4g_beacons = hidl_request.debugConfigs.validUseBeaconsInBandVal;
992 legacy_request->beacon_2dot4g_val = hidl_request.debugConfigs
993 .useBeaconsInBandVal[(size_t) NanBandIndex::NAN_BAND_24GHZ];
994 legacy_request->config_5g_beacons = hidl_request.debugConfigs.validUseBeaconsInBandVal;
995 legacy_request->beacon_5g_val = hidl_request.debugConfigs
996 .useBeaconsInBandVal[(size_t) NanBandIndex::NAN_BAND_5GHZ];
997 legacy_request->config_2dot4g_sdf = hidl_request.debugConfigs.validUseSdfInBandVal;
998 legacy_request->sdf_2dot4g_val = hidl_request.debugConfigs
999 .useSdfInBandVal[(size_t) NanBandIndex::NAN_BAND_24GHZ];
1000 legacy_request->config_5g_sdf = hidl_request.debugConfigs.validUseSdfInBandVal;
1001 legacy_request->sdf_5g_val = hidl_request.debugConfigs
1002 .useSdfInBandVal[(size_t) NanBandIndex::NAN_BAND_5GHZ];
1003
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001004 return true;
1005}
1006
1007bool convertHidlNanPublishRequestToLegacy(
1008 const NanPublishRequest& hidl_request,
1009 legacy_hal::NanPublishRequest* legacy_request) {
1010 if (!legacy_request) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001011 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: null legacy_request";
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001012 return false;
1013 }
Roshan Pius590744b2017-03-02 07:24:41 -08001014 *legacy_request = {};
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001015
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001016 legacy_request->publish_id = hidl_request.baseConfigs.sessionId;
1017 legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
1018 legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
1019 legacy_request->publish_count = hidl_request.baseConfigs.discoveryCount;
1020 legacy_request->service_name_len = hidl_request.baseConfigs.serviceName.size();
1021 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001022 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: service_name_len too large";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001023 return false;
1024 }
Etan Cohen4bbc2092017-01-30 13:28:37 -08001025 memcpy(legacy_request->service_name, hidl_request.baseConfigs.serviceName.data(),
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001026 legacy_request->service_name_len);
1027 legacy_request->publish_match_indicator =
Etan Cohen67d378d2017-04-03 16:10:54 -07001028 convertHidlNanMatchAlgToLegacy(hidl_request.baseConfigs.discoveryMatchIndicator);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001029 legacy_request->service_specific_info_len = hidl_request.baseConfigs.serviceSpecificInfo.size();
1030 if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001031 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: service_specific_info_len too large";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001032 return false;
1033 }
1034 memcpy(legacy_request->service_specific_info,
1035 hidl_request.baseConfigs.serviceSpecificInfo.data(),
1036 legacy_request->service_specific_info_len);
Etan Cohena7543a72017-02-17 13:46:19 -08001037 legacy_request->sdea_service_specific_info_len =
1038 hidl_request.baseConfigs.extendedServiceSpecificInfo.size();
1039 if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1040 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: sdea_service_specific_info_len too large";
1041 return false;
1042 }
1043 memcpy(legacy_request->sdea_service_specific_info,
1044 hidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
1045 legacy_request->sdea_service_specific_info_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001046 legacy_request->rx_match_filter_len = hidl_request.baseConfigs.rxMatchFilter.size();
1047 if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001048 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: rx_match_filter_len too large";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001049 return false;
1050 }
1051 memcpy(legacy_request->rx_match_filter,
1052 hidl_request.baseConfigs.rxMatchFilter.data(),
1053 legacy_request->rx_match_filter_len);
1054 legacy_request->tx_match_filter_len = hidl_request.baseConfigs.txMatchFilter.size();
1055 if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001056 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: tx_match_filter_len too large";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001057 return false;
1058 }
1059 memcpy(legacy_request->tx_match_filter,
1060 hidl_request.baseConfigs.txMatchFilter.data(),
1061 legacy_request->tx_match_filter_len);
1062 legacy_request->rssi_threshold_flag = hidl_request.baseConfigs.useRssiThreshold;
1063 legacy_request->recv_indication_cfg = 0;
1064 legacy_request->recv_indication_cfg |=
1065 hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1 : 0x0;
1066 legacy_request->recv_indication_cfg |=
1067 hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
1068 legacy_request->recv_indication_cfg |=
1069 hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
Etan Cohenc58619e2017-03-14 14:54:40 -07001070 legacy_request->cipher_type = (unsigned int) hidl_request.baseConfigs.securityConfig.cipherType;
1071 if (hidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PMK) {
1072 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1073 legacy_request->key_info.body.pmk_info.pmk_len =
1074 hidl_request.baseConfigs.securityConfig.pmk.size();
1075 if (legacy_request->key_info.body.pmk_info.pmk_len > NAN_PMK_INFO_LEN) {
1076 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: pmk_len too large";
1077 return false;
1078 }
1079 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1080 hidl_request.baseConfigs.securityConfig.pmk.data(),
1081 legacy_request->key_info.body.pmk_info.pmk_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001082 }
Etan Cohenc58619e2017-03-14 14:54:40 -07001083 if (hidl_request.baseConfigs.securityConfig.securityType
1084 == NanDataPathSecurityType::PASSPHRASE) {
1085 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1086 legacy_request->key_info.body.passphrase_info.passphrase_len =
1087 hidl_request.baseConfigs.securityConfig.passphrase.size();
1088 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1089 < NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1090 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: passphrase_len too small";
1091 return false;
1092 }
1093 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1094 > NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1095 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: passphrase_len too large";
1096 return false;
1097 }
1098 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1099 hidl_request.baseConfigs.securityConfig.passphrase.data(),
1100 legacy_request->key_info.body.passphrase_info.passphrase_len);
1101 }
1102 legacy_request->sdea_params.security_cfg = (hidl_request.baseConfigs.securityConfig.securityType
1103 != NanDataPathSecurityType::OPEN) ? legacy_hal::NAN_DP_CONFIG_SECURITY
1104 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001105 legacy_request->sdea_params.ranging_state = hidl_request.baseConfigs.rangingRequired ?
1106 legacy_hal::NAN_RANGING_ENABLE : legacy_hal::NAN_RANGING_DISABLE;
1107 legacy_request->ranging_cfg.ranging_interval_msec = hidl_request.baseConfigs.rangingIntervalMsec;
1108 legacy_request->ranging_cfg.config_ranging_indications =
1109 hidl_request.baseConfigs.configRangingIndications;
1110 legacy_request->ranging_cfg.distance_ingress_cm = hidl_request.baseConfigs.distanceIngressCm;
1111 legacy_request->ranging_cfg.distance_egress_cm = hidl_request.baseConfigs.distanceEgressCm;
Etan Cohenc190f932017-02-17 13:06:55 -08001112 legacy_request->ranging_auto_response = hidl_request.baseConfigs.rangingRequired ?
1113 legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
Etan Cohen5b804212017-03-08 11:44:01 -08001114 legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT;
Etan Cohen67d378d2017-04-03 16:10:54 -07001115 legacy_request->publish_type = convertHidlNanPublishTypeToLegacy(hidl_request.publishType);
1116 legacy_request->tx_type = convertHidlNanTxTypeToLegacy(hidl_request.txType);
Etan Cohen3c5d8ae2017-02-22 12:54:20 -08001117 legacy_request->service_responder_policy = hidl_request.autoAcceptDataPathRequests ?
1118 legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL : legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001119
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001120 return true;
1121}
1122
1123bool convertHidlNanSubscribeRequestToLegacy(
1124 const NanSubscribeRequest& hidl_request,
1125 legacy_hal::NanSubscribeRequest* legacy_request) {
1126 if (!legacy_request) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001127 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: legacy_request is null";
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001128 return false;
1129 }
Roshan Pius590744b2017-03-02 07:24:41 -08001130 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001131
1132 legacy_request->subscribe_id = hidl_request.baseConfigs.sessionId;
1133 legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
1134 legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
1135 legacy_request->subscribe_count = hidl_request.baseConfigs.discoveryCount;
1136 legacy_request->service_name_len = hidl_request.baseConfigs.serviceName.size();
1137 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001138 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: service_name_len too large";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001139 return false;
1140 }
Etan Cohen4bbc2092017-01-30 13:28:37 -08001141 memcpy(legacy_request->service_name, hidl_request.baseConfigs.serviceName.data(),
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001142 legacy_request->service_name_len);
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001143 legacy_request->subscribe_match_indicator =
Etan Cohen67d378d2017-04-03 16:10:54 -07001144 convertHidlNanMatchAlgToLegacy(hidl_request.baseConfigs.discoveryMatchIndicator);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001145 legacy_request->service_specific_info_len = hidl_request.baseConfigs.serviceSpecificInfo.size();
1146 if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001147 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: service_specific_info_len too large";
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001148 return false;
1149 }
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001150 memcpy(legacy_request->service_specific_info,
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001151 hidl_request.baseConfigs.serviceSpecificInfo.data(),
1152 legacy_request->service_specific_info_len);
Etan Cohena7543a72017-02-17 13:46:19 -08001153 legacy_request->sdea_service_specific_info_len =
1154 hidl_request.baseConfigs.extendedServiceSpecificInfo.size();
1155 if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1156 LOG(ERROR) <<
1157 "convertHidlNanSubscribeRequestToLegacy: sdea_service_specific_info_len too large";
1158 return false;
1159 }
1160 memcpy(legacy_request->sdea_service_specific_info,
1161 hidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
1162 legacy_request->sdea_service_specific_info_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001163 legacy_request->rx_match_filter_len = hidl_request.baseConfigs.rxMatchFilter.size();
1164 if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001165 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: rx_match_filter_len too large";
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001166 return false;
1167 }
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001168 memcpy(legacy_request->rx_match_filter,
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001169 hidl_request.baseConfigs.rxMatchFilter.data(),
1170 legacy_request->rx_match_filter_len);
1171 legacy_request->tx_match_filter_len = hidl_request.baseConfigs.txMatchFilter.size();
1172 if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001173 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: tx_match_filter_len too large";
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001174 return false;
1175 }
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001176 memcpy(legacy_request->tx_match_filter,
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001177 hidl_request.baseConfigs.txMatchFilter.data(),
1178 legacy_request->tx_match_filter_len);
1179 legacy_request->rssi_threshold_flag = hidl_request.baseConfigs.useRssiThreshold;
1180 legacy_request->recv_indication_cfg = 0;
1181 legacy_request->recv_indication_cfg |=
1182 hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1 : 0x0;
1183 legacy_request->recv_indication_cfg |=
1184 hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
1185 legacy_request->recv_indication_cfg |=
1186 hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
Etan Cohenc58619e2017-03-14 14:54:40 -07001187 legacy_request->cipher_type = (unsigned int) hidl_request.baseConfigs.securityConfig.cipherType;
1188 if (hidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PMK) {
1189 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1190 legacy_request->key_info.body.pmk_info.pmk_len =
1191 hidl_request.baseConfigs.securityConfig.pmk.size();
1192 if (legacy_request->key_info.body.pmk_info.pmk_len > NAN_PMK_INFO_LEN) {
1193 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: pmk_len too large";
1194 return false;
1195 }
1196 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1197 hidl_request.baseConfigs.securityConfig.pmk.data(),
1198 legacy_request->key_info.body.pmk_info.pmk_len);
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001199 }
Etan Cohenc58619e2017-03-14 14:54:40 -07001200 if (hidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) {
1201 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1202 legacy_request->key_info.body.passphrase_info.passphrase_len =
1203 hidl_request.baseConfigs.securityConfig.passphrase.size();
1204 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1205 < NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1206 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: passphrase_len too small";
1207 return false;
1208 }
1209 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1210 > NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1211 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: passphrase_len too large";
1212 return false;
1213 }
1214 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1215 hidl_request.baseConfigs.securityConfig.passphrase.data(),
1216 legacy_request->key_info.body.passphrase_info.passphrase_len);
1217 }
1218 legacy_request->sdea_params.security_cfg = (hidl_request.baseConfigs.securityConfig.securityType
1219 != NanDataPathSecurityType::OPEN) ? legacy_hal::NAN_DP_CONFIG_SECURITY
1220 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001221 legacy_request->sdea_params.ranging_state = hidl_request.baseConfigs.rangingRequired ?
1222 legacy_hal::NAN_RANGING_ENABLE : legacy_hal::NAN_RANGING_DISABLE;
1223 legacy_request->ranging_cfg.ranging_interval_msec = hidl_request.baseConfigs.rangingIntervalMsec;
1224 legacy_request->ranging_cfg.config_ranging_indications =
1225 hidl_request.baseConfigs.configRangingIndications;
1226 legacy_request->ranging_cfg.distance_ingress_cm = hidl_request.baseConfigs.distanceIngressCm;
1227 legacy_request->ranging_cfg.distance_egress_cm = hidl_request.baseConfigs.distanceEgressCm;
Etan Cohenc190f932017-02-17 13:06:55 -08001228 legacy_request->ranging_auto_response = hidl_request.baseConfigs.rangingRequired ?
1229 legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
Etan Cohen5b804212017-03-08 11:44:01 -08001230 legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT;
Etan Cohen67d378d2017-04-03 16:10:54 -07001231 legacy_request->subscribe_type = convertHidlNanSubscribeTypeToLegacy(hidl_request.subscribeType);
1232 legacy_request->serviceResponseFilter = convertHidlNanSrfTypeToLegacy(hidl_request.srfType);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001233 legacy_request->serviceResponseInclude = hidl_request.srfRespondIfInAddressSet ?
1234 legacy_hal::NAN_SRF_INCLUDE_RESPOND : legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
1235 legacy_request->useServiceResponseFilter = hidl_request.shouldUseSrf ?
1236 legacy_hal::NAN_USE_SRF : legacy_hal::NAN_DO_NOT_USE_SRF;
1237 legacy_request->ssiRequiredForMatchIndication = hidl_request.isSsiRequiredForMatch ?
1238 legacy_hal::NAN_SSI_REQUIRED_IN_MATCH_IND : legacy_hal::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001239 legacy_request->num_intf_addr_present = hidl_request.intfAddr.size();
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001240 if (legacy_request->num_intf_addr_present > NAN_MAX_SUBSCRIBE_MAX_ADDRESS) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001241 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: num_intf_addr_present - too many";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001242 return false;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001243 }
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001244 for (int i = 0; i < legacy_request->num_intf_addr_present; i++) {
1245 memcpy(legacy_request->intf_addr[i], hidl_request.intfAddr[i].data(), 6);
1246 }
1247
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001248 return true;
1249}
1250
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001251bool convertHidlNanTransmitFollowupRequestToLegacy(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001252 const NanTransmitFollowupRequest& hidl_request,
1253 legacy_hal::NanTransmitFollowupRequest* legacy_request) {
1254 if (!legacy_request) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001255 LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: legacy_request is null";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001256 return false;
1257 }
Roshan Pius590744b2017-03-02 07:24:41 -08001258 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001259
1260 legacy_request->publish_subscribe_id = hidl_request.discoverySessionId;
1261 legacy_request->requestor_instance_id = hidl_request.peerId;
1262 memcpy(legacy_request->addr, hidl_request.addr.data(), 6);
1263 legacy_request->priority = hidl_request.isHighPriority ?
1264 legacy_hal::NAN_TX_PRIORITY_HIGH : legacy_hal::NAN_TX_PRIORITY_NORMAL;
1265 legacy_request->dw_or_faw = hidl_request.shouldUseDiscoveryWindow ?
1266 legacy_hal::NAN_TRANSMIT_IN_DW : legacy_hal::NAN_TRANSMIT_IN_FAW;
Etan Cohen44983ae2017-02-09 09:16:25 -08001267 legacy_request->service_specific_info_len = hidl_request.serviceSpecificInfo.size();
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001268 if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
Etan Cohena7543a72017-02-17 13:46:19 -08001269 LOG(ERROR) <<
1270 "convertHidlNanTransmitFollowupRequestToLegacy: service_specific_info_len too large";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001271 return false;
1272 }
1273 memcpy(legacy_request->service_specific_info,
Etan Cohen44983ae2017-02-09 09:16:25 -08001274 hidl_request.serviceSpecificInfo.data(),
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001275 legacy_request->service_specific_info_len);
Etan Cohena7543a72017-02-17 13:46:19 -08001276 legacy_request->sdea_service_specific_info_len = hidl_request.extendedServiceSpecificInfo.size();
1277 if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1278 LOG(ERROR) <<
1279 "convertHidlNanTransmitFollowupRequestToLegacy: sdea_service_specific_info_len too large";
1280 return false;
1281 }
1282 memcpy(legacy_request->sdea_service_specific_info,
1283 hidl_request.extendedServiceSpecificInfo.data(),
1284 legacy_request->sdea_service_specific_info_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001285 legacy_request->recv_indication_cfg = hidl_request.disableFollowupResultIndication ? 0x1 : 0x0;
1286
1287 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001288}
1289
1290bool convertHidlNanConfigRequestToLegacy(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001291 const NanConfigRequest& hidl_request,
1292 legacy_hal::NanConfigRequest* legacy_request) {
1293 if (!legacy_request) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001294 LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: legacy_request is null";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001295 return false;
1296 }
Roshan Pius590744b2017-03-02 07:24:41 -08001297 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001298
1299 // TODO: b/34059183 tracks missing configurations in legacy HAL or uknown defaults
1300 legacy_request->master_pref = hidl_request.masterPref;
1301 legacy_request->discovery_indication_cfg = 0;
1302 legacy_request->discovery_indication_cfg |=
1303 hidl_request.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
1304 legacy_request->discovery_indication_cfg |=
1305 hidl_request.disableStartedClusterIndication ? 0x2 : 0x0;
1306 legacy_request->discovery_indication_cfg |=
1307 hidl_request.disableJoinedClusterIndication ? 0x4 : 0x0;
1308 legacy_request->config_sid_beacon = 1;
Etan Cohen44983ae2017-02-09 09:16:25 -08001309 if (hidl_request.numberOfPublishServiceIdsInBeacon > 127) {
1310 LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: numberOfPublishServiceIdsInBeacon > 127";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001311 return false;
1312 }
Etan Cohen44983ae2017-02-09 09:16:25 -08001313 legacy_request->sid_beacon = (hidl_request.includePublishServiceIdsInBeacon ? 0x1 : 0x0)
1314 | (hidl_request.numberOfPublishServiceIdsInBeacon << 1);
Etan Cohenb9b71ce2017-02-09 12:55:23 -08001315 // TODO: b/35195516 connect SubscribeServiceIds to legacy HAL once implemented
Etan Cohen4bbc2092017-01-30 13:28:37 -08001316 legacy_request->config_rssi_window_size = 1;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001317 legacy_request->rssi_window_size_val = hidl_request.rssiWindowSize;
1318 legacy_request->config_disc_mac_addr_randomization = 1;
1319 legacy_request->disc_mac_addr_rand_interval_sec =
1320 hidl_request.macAddressRandomizationIntervalSec;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001321 /* TODO : missing
Etan Cohen4bbc2092017-01-30 13:28:37 -08001322 legacy_request->config_2dot4g_rssi_close = 1;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001323 legacy_request->rssi_close_2dot4g_val =
1324 hidl_request.bandSpecificConfig[
1325 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiClose;
Etan Cohen4bbc2092017-01-30 13:28:37 -08001326 legacy_request->config_2dot4g_rssi_middle = 1;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001327 legacy_request->rssi_middle_2dot4g_val =
1328 hidl_request.bandSpecificConfig[
1329 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiMiddle;
Etan Cohen4bbc2092017-01-30 13:28:37 -08001330 legacy_request->config_2dot4g_rssi_proximity = 1;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001331 legacy_request->rssi_proximity_2dot4g_val =
1332 hidl_request.bandSpecificConfig[
Etan Cohen44983ae2017-02-09 09:16:25 -08001333 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiCloseProximity;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001334 */
Etan Cohen4bbc2092017-01-30 13:28:37 -08001335 legacy_request->config_scan_params = 1;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001336 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
1337 hidl_request.bandSpecificConfig[
1338 (size_t) NanBandIndex::NAN_BAND_24GHZ].dwellTimeMs;
1339 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
1340 hidl_request.bandSpecificConfig[
1341 (size_t) NanBandIndex::NAN_BAND_24GHZ].scanPeriodSec;
1342 legacy_request->config_dw.config_2dot4g_dw_band = hidl_request
1343 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].validDiscoveryWindowIntervalVal;
1344 legacy_request->config_dw.dw_2dot4g_interval_val = hidl_request
1345 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].discoveryWindowIntervalVal;
1346 /* TODO: missing
Etan Cohen4bbc2092017-01-30 13:28:37 -08001347 legacy_request->config_5g_rssi_close = 1;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001348 legacy_request->rssi_close_5g_val =
1349 hidl_request.bandSpecificConfig[
1350 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiClose;
Etan Cohen4bbc2092017-01-30 13:28:37 -08001351 legacy_request->config_5g_rssi_middle = 1;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001352 legacy_request->rssi_middle_5g_val =
1353 hidl_request.bandSpecificConfig[
1354 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiMiddle;
1355 */
Etan Cohen4bbc2092017-01-30 13:28:37 -08001356 legacy_request->config_5g_rssi_close_proximity = 1;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001357 legacy_request->rssi_close_proximity_5g_val =
1358 hidl_request.bandSpecificConfig[
Etan Cohen44983ae2017-02-09 09:16:25 -08001359 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiCloseProximity;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001360 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1361 hidl_request.bandSpecificConfig[
1362 (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
1363 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1364 hidl_request.bandSpecificConfig[
1365 (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
1366 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1367 hidl_request.bandSpecificConfig[
1368 (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
1369 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1370 hidl_request.bandSpecificConfig[
1371 (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
1372 legacy_request->config_dw.config_5g_dw_band = hidl_request
1373 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].validDiscoveryWindowIntervalVal;
1374 legacy_request->config_dw.dw_5g_interval_val = hidl_request
1375 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].discoveryWindowIntervalVal;
1376
1377 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001378}
1379
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001380bool convertHidlNanDataPathInitiatorRequestToLegacy(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001381 const NanInitiateDataPathRequest& hidl_request,
1382 legacy_hal::NanDataPathInitiatorRequest* legacy_request) {
1383 if (!legacy_request) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001384 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: legacy_request is null";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001385 return false;
1386 }
Roshan Pius590744b2017-03-02 07:24:41 -08001387 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001388
1389 legacy_request->requestor_instance_id = hidl_request.peerId;
1390 memcpy(legacy_request->peer_disc_mac_addr, hidl_request.peerDiscMacAddr.data(), 6);
1391 legacy_request->channel_request_type =
Etan Cohen67d378d2017-04-03 16:10:54 -07001392 convertHidlNanDataPathChannelCfgToLegacy(hidl_request.channelRequestType);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001393 legacy_request->channel = hidl_request.channel;
1394 strcpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str());
Etan Cohenc58619e2017-03-14 14:54:40 -07001395 legacy_request->ndp_cfg.security_cfg = (hidl_request.securityConfig.securityType
1396 != NanDataPathSecurityType::OPEN) ? legacy_hal::NAN_DP_CONFIG_SECURITY
1397 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001398 legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
1399 if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
Etan Cohend1889842017-02-22 12:54:20 -08001400 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: ndp_app_info_len too large";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001401 return false;
1402 }
1403 memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
1404 legacy_request->app_info.ndp_app_info_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001405 legacy_request->cipher_type = (unsigned int) hidl_request.securityConfig.cipherType;
1406 if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PMK) {
1407 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1408 legacy_request->key_info.body.pmk_info.pmk_len = hidl_request.securityConfig.pmk.size();
1409 if (legacy_request->key_info.body.pmk_info.pmk_len > NAN_PMK_INFO_LEN) {
1410 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: pmk_len too large";
1411 return false;
1412 }
1413 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1414 hidl_request.securityConfig.pmk.data(),
1415 legacy_request->key_info.body.pmk_info.pmk_len);
1416 }
1417 if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) {
1418 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1419 legacy_request->key_info.body.passphrase_info.passphrase_len =
1420 hidl_request.securityConfig.passphrase.size();
1421 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1422 < NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1423 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: passphrase_len too small";
1424 return false;
1425 }
1426 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1427 > NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1428 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: passphrase_len too large";
1429 return false;
1430 }
1431 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1432 hidl_request.securityConfig.passphrase.data(),
1433 legacy_request->key_info.body.passphrase_info.passphrase_len);
1434 }
1435 legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
1436 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1437 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: service_name_len too large";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001438 return false;
1439 }
Etan Cohenc58619e2017-03-14 14:54:40 -07001440 memcpy(legacy_request->service_name, hidl_request.serviceNameOutOfBand.data(),
1441 legacy_request->service_name_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001442
1443 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001444}
1445
1446bool convertHidlNanDataPathIndicationResponseToLegacy(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001447 const NanRespondToDataPathIndicationRequest& hidl_request,
1448 legacy_hal::NanDataPathIndicationResponse* legacy_request) {
1449 if (!legacy_request) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001450 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: legacy_request is null";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001451 return false;
1452 }
Roshan Pius590744b2017-03-02 07:24:41 -08001453 *legacy_request = {};
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001454
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001455 legacy_request->rsp_code = hidl_request.acceptRequest ?
1456 legacy_hal::NAN_DP_REQUEST_ACCEPT : legacy_hal::NAN_DP_REQUEST_REJECT;
1457 legacy_request->ndp_instance_id = hidl_request.ndpInstanceId;
1458 strcpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str());
Etan Cohenc58619e2017-03-14 14:54:40 -07001459 legacy_request->ndp_cfg.security_cfg = (hidl_request.securityConfig.securityType
1460 != NanDataPathSecurityType::OPEN) ? legacy_hal::NAN_DP_CONFIG_SECURITY
1461 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001462 legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
1463 if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001464 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: ndp_app_info_len too large";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001465 return false;
1466 }
1467 memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
1468 legacy_request->app_info.ndp_app_info_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001469 legacy_request->cipher_type = (unsigned int) hidl_request.securityConfig.cipherType;
1470 if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PMK) {
1471 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1472 legacy_request->key_info.body.pmk_info.pmk_len = hidl_request.securityConfig.pmk.size();
1473 if (legacy_request->key_info.body.pmk_info.pmk_len > NAN_PMK_INFO_LEN) {
1474 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: pmk_len too large";
1475 return false;
1476 }
1477 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1478 hidl_request.securityConfig.pmk.data(),
1479 legacy_request->key_info.body.pmk_info.pmk_len);
1480 }
1481 if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) {
1482 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1483 legacy_request->key_info.body.passphrase_info.passphrase_len =
1484 hidl_request.securityConfig.passphrase.size();
1485 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1486 < NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1487 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: passphrase_len too small";
1488 return false;
1489 }
1490 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1491 > NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1492 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: passphrase_len too large";
1493 return false;
1494 }
1495 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1496 hidl_request.securityConfig.passphrase.data(),
1497 legacy_request->key_info.body.passphrase_info.passphrase_len);
1498 }
1499 legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
1500 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1501 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: service_name_len too large";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001502 return false;
1503 }
Etan Cohenc58619e2017-03-14 14:54:40 -07001504 memcpy(legacy_request->service_name, hidl_request.serviceNameOutOfBand.data(),
1505 legacy_request->service_name_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001506
1507 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001508}
1509
1510bool convertLegacyNanResponseHeaderToHidl(
1511 const legacy_hal::NanResponseMsg& legacy_response,
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001512 WifiNanStatus* wifiNanStatus) {
1513 if (!wifiNanStatus) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001514 LOG(ERROR) << "convertLegacyNanResponseHeaderToHidl: wifiNanStatus is null";
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001515 return false;
1516 }
Roshan Pius590744b2017-03-02 07:24:41 -08001517 *wifiNanStatus = {};
1518
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001519 wifiNanStatus->status = convertLegacyNanStatusTypeToHidl(legacy_response.status);
1520 wifiNanStatus->description = legacy_response.nan_error;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001521 return true;
1522}
1523
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001524bool convertLegacyNanCapabilitiesResponseToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001525 const legacy_hal::NanCapabilities& legacy_response,
1526 NanCapabilities* hidl_response) {
1527 if (!hidl_response) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001528 LOG(ERROR) << "convertLegacyNanCapabilitiesResponseToHidl: hidl_response is null";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001529 return false;
1530 }
Roshan Pius590744b2017-03-02 07:24:41 -08001531 *hidl_response = {};
1532
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001533 hidl_response->maxConcurrentClusters = legacy_response.max_concurrent_nan_clusters;
1534 hidl_response->maxPublishes = legacy_response.max_publishes;
1535 hidl_response->maxSubscribes = legacy_response.max_subscribes;
1536 hidl_response->maxServiceNameLen = legacy_response.max_service_name_len;
1537 hidl_response->maxMatchFilterLen = legacy_response.max_match_filter_len;
1538 hidl_response->maxTotalMatchFilterLen = legacy_response.max_total_match_filter_len;
1539 hidl_response->maxServiceSpecificInfoLen = legacy_response.max_service_specific_info_len;
Etan Cohena7543a72017-02-17 13:46:19 -08001540 hidl_response->maxExtendedServiceSpecificInfoLen =
1541 legacy_response.max_sdea_service_specific_info_len;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001542 hidl_response->maxNdiInterfaces = legacy_response.max_ndi_interfaces;
1543 hidl_response->maxNdpSessions = legacy_response.max_ndp_sessions;
1544 hidl_response->maxAppInfoLen = legacy_response.max_app_info_len;
1545 hidl_response->maxQueuedTransmitFollowupMsgs = legacy_response.max_queued_transmit_followup_msgs;
Etan Cohen09a604b2017-02-16 13:02:43 -08001546 hidl_response->maxSubscribeInterfaceAddresses = legacy_response.max_subscribe_address;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001547 hidl_response->supportedCipherSuites = legacy_response.cipher_suites_supported;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001548
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001549 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001550}
1551
1552bool convertLegacyNanMatchIndToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001553 const legacy_hal::NanMatchInd& legacy_ind,
1554 NanMatchInd* hidl_ind) {
1555 if (!hidl_ind) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001556 LOG(ERROR) << "convertLegacyNanMatchIndToHidl: hidl_ind is null";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001557 return false;
1558 }
Roshan Pius590744b2017-03-02 07:24:41 -08001559 *hidl_ind = {};
1560
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001561 hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
1562 hidl_ind->peerId = legacy_ind.requestor_instance_id;
1563 hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
1564 hidl_ind->serviceSpecificInfo = std::vector<uint8_t>(legacy_ind.service_specific_info,
1565 legacy_ind.service_specific_info + legacy_ind.service_specific_info_len);
Etan Cohena7543a72017-02-17 13:46:19 -08001566 hidl_ind->extendedServiceSpecificInfo = std::vector<uint8_t>(
1567 legacy_ind.sdea_service_specific_info,
1568 legacy_ind.sdea_service_specific_info + legacy_ind.sdea_service_specific_info_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001569 hidl_ind->matchFilter = std::vector<uint8_t>(legacy_ind.sdf_match_filter,
1570 legacy_ind.sdf_match_filter + legacy_ind.sdf_match_filter_len);
1571 hidl_ind->matchOccuredInBeaconFlag = legacy_ind.match_occured_flag == 1;
1572 hidl_ind->outOfResourceFlag = legacy_ind.out_of_resource_flag == 1;
1573 hidl_ind->rssiValue = legacy_ind.rssi_value;
Etan Cohend1889842017-02-22 12:54:20 -08001574 hidl_ind->peerCipherType = (NanCipherSuiteType) legacy_ind.peer_cipher_type;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001575 hidl_ind->peerRequiresSecurityEnabledInNdp =
1576 legacy_ind.peer_sdea_params.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
1577 hidl_ind->peerRequiresRanging =
1578 legacy_ind.peer_sdea_params.ranging_state == legacy_hal::NAN_RANGING_ENABLE;
Etan Cohenc190f932017-02-17 13:06:55 -08001579 hidl_ind->rangingMeasurementInCm = legacy_ind.range_info.range_measurement_cm;
1580 hidl_ind->rangingIndicationType = legacy_ind.range_info.ranging_event_type;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001581
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001582 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001583}
1584
1585bool convertLegacyNanFollowupIndToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001586 const legacy_hal::NanFollowupInd& legacy_ind,
1587 NanFollowupReceivedInd* hidl_ind) {
1588 if (!hidl_ind) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001589 LOG(ERROR) << "convertLegacyNanFollowupIndToHidl: hidl_ind is null";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001590 return false;
1591 }
Roshan Pius590744b2017-03-02 07:24:41 -08001592 *hidl_ind = {};
1593
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001594 hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
1595 hidl_ind->peerId = legacy_ind.requestor_instance_id;
1596 hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
1597 hidl_ind->receivedInFaw = legacy_ind.dw_or_faw == 1;
Etan Cohen44983ae2017-02-09 09:16:25 -08001598 hidl_ind->serviceSpecificInfo = std::vector<uint8_t>(legacy_ind.service_specific_info,
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001599 legacy_ind.service_specific_info + legacy_ind.service_specific_info_len);
Etan Cohena7543a72017-02-17 13:46:19 -08001600 hidl_ind->extendedServiceSpecificInfo = std::vector<uint8_t>(
1601 legacy_ind.sdea_service_specific_info,
1602 legacy_ind.sdea_service_specific_info + legacy_ind.sdea_service_specific_info_len);
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001603
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001604 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001605}
1606
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001607bool convertLegacyNanDataPathRequestIndToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001608 const legacy_hal::NanDataPathRequestInd& legacy_ind,
1609 NanDataPathRequestInd* hidl_ind) {
1610 if (!hidl_ind) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001611 LOG(ERROR) << "convertLegacyNanDataPathRequestIndToHidl: hidl_ind is null";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001612 return false;
1613 }
Roshan Pius590744b2017-03-02 07:24:41 -08001614 *hidl_ind = {};
1615
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001616 hidl_ind->discoverySessionId = legacy_ind.service_instance_id;
1617 hidl_ind->peerDiscMacAddr = hidl_array<uint8_t, 6>(legacy_ind.peer_disc_mac_addr);
1618 hidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
1619 hidl_ind->securityRequired =
1620 legacy_ind.ndp_cfg.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
1621 hidl_ind->appInfo = std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info,
1622 legacy_ind.app_info.ndp_app_info + legacy_ind.app_info.ndp_app_info_len);
1623
1624 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001625}
1626
1627bool convertLegacyNanDataPathConfirmIndToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001628 const legacy_hal::NanDataPathConfirmInd& legacy_ind,
1629 NanDataPathConfirmInd* hidl_ind) {
1630 if (!hidl_ind) {
Etan Cohen4bbc2092017-01-30 13:28:37 -08001631 LOG(ERROR) << "convertLegacyNanDataPathConfirmIndToHidl: hidl_ind is null";
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001632 return false;
1633 }
Roshan Pius590744b2017-03-02 07:24:41 -08001634 *hidl_ind = {};
1635
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001636 hidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
1637 hidl_ind->dataPathSetupSuccess = legacy_ind.rsp_code == legacy_hal::NAN_DP_REQUEST_ACCEPT;
1638 hidl_ind->peerNdiMacAddr = hidl_array<uint8_t, 6>(legacy_ind.peer_ndi_mac_addr);
1639 hidl_ind->appInfo = std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info,
1640 legacy_ind.app_info.ndp_app_info + legacy_ind.app_info.ndp_app_info_len);
1641 hidl_ind->status.status = convertLegacyNanStatusTypeToHidl(legacy_ind.reason_code);
1642 hidl_ind->status.description = ""; // TODO: b/34059183
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001643
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001644 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001645}
Roshan Pius3fae9c82016-12-02 14:49:41 -08001646
1647legacy_hal::wifi_rtt_type convertHidlRttTypeToLegacy(RttType type) {
1648 switch (type) {
1649 case RttType::ONE_SIDED:
1650 return legacy_hal::RTT_TYPE_1_SIDED;
1651 case RttType::TWO_SIDED:
1652 return legacy_hal::RTT_TYPE_2_SIDED;
1653 };
1654 CHECK(false);
1655}
1656
1657RttType convertLegacyRttTypeToHidl(legacy_hal::wifi_rtt_type type) {
1658 switch (type) {
1659 case legacy_hal::RTT_TYPE_1_SIDED:
1660 return RttType::ONE_SIDED;
1661 case legacy_hal::RTT_TYPE_2_SIDED:
1662 return RttType::TWO_SIDED;
1663 };
1664 CHECK(false) << "Unknown legacy type: " << type;
1665}
1666
1667legacy_hal::rtt_peer_type convertHidlRttPeerTypeToLegacy(RttPeerType type) {
1668 switch (type) {
1669 case RttPeerType::AP:
1670 return legacy_hal::RTT_PEER_AP;
1671 case RttPeerType::STA:
1672 return legacy_hal::RTT_PEER_STA;
1673 case RttPeerType::P2P_GO:
1674 return legacy_hal::RTT_PEER_P2P_GO;
1675 case RttPeerType::P2P_CLIENT:
1676 return legacy_hal::RTT_PEER_P2P_CLIENT;
1677 case RttPeerType::NAN:
1678 return legacy_hal::RTT_PEER_NAN;
1679 };
1680 CHECK(false);
1681}
1682
1683legacy_hal::wifi_channel_width convertHidlWifiChannelWidthToLegacy(
1684 WifiChannelWidthInMhz type) {
1685 switch (type) {
1686 case WifiChannelWidthInMhz::WIDTH_20:
1687 return legacy_hal::WIFI_CHAN_WIDTH_20;
1688 case WifiChannelWidthInMhz::WIDTH_40:
1689 return legacy_hal::WIFI_CHAN_WIDTH_40;
1690 case WifiChannelWidthInMhz::WIDTH_80:
1691 return legacy_hal::WIFI_CHAN_WIDTH_80;
1692 case WifiChannelWidthInMhz::WIDTH_160:
1693 return legacy_hal::WIFI_CHAN_WIDTH_160;
1694 case WifiChannelWidthInMhz::WIDTH_80P80:
1695 return legacy_hal::WIFI_CHAN_WIDTH_80P80;
1696 case WifiChannelWidthInMhz::WIDTH_5:
1697 return legacy_hal::WIFI_CHAN_WIDTH_5;
1698 case WifiChannelWidthInMhz::WIDTH_10:
1699 return legacy_hal::WIFI_CHAN_WIDTH_10;
1700 case WifiChannelWidthInMhz::WIDTH_INVALID:
1701 return legacy_hal::WIFI_CHAN_WIDTH_INVALID;
1702 };
1703 CHECK(false);
1704}
1705
1706WifiChannelWidthInMhz convertLegacyWifiChannelWidthToHidl(
1707 legacy_hal::wifi_channel_width type) {
1708 switch (type) {
1709 case legacy_hal::WIFI_CHAN_WIDTH_20:
1710 return WifiChannelWidthInMhz::WIDTH_20;
1711 case legacy_hal::WIFI_CHAN_WIDTH_40:
1712 return WifiChannelWidthInMhz::WIDTH_40;
1713 case legacy_hal::WIFI_CHAN_WIDTH_80:
1714 return WifiChannelWidthInMhz::WIDTH_80;
1715 case legacy_hal::WIFI_CHAN_WIDTH_160:
1716 return WifiChannelWidthInMhz::WIDTH_160;
1717 case legacy_hal::WIFI_CHAN_WIDTH_80P80:
1718 return WifiChannelWidthInMhz::WIDTH_80P80;
1719 case legacy_hal::WIFI_CHAN_WIDTH_5:
1720 return WifiChannelWidthInMhz::WIDTH_5;
1721 case legacy_hal::WIFI_CHAN_WIDTH_10:
1722 return WifiChannelWidthInMhz::WIDTH_10;
1723 case legacy_hal::WIFI_CHAN_WIDTH_INVALID:
1724 return WifiChannelWidthInMhz::WIDTH_INVALID;
1725 };
1726 CHECK(false) << "Unknown legacy type: " << type;
1727}
1728
1729legacy_hal::wifi_rtt_preamble convertHidlRttPreambleToLegacy(RttPreamble type) {
1730 switch (type) {
1731 case RttPreamble::LEGACY:
1732 return legacy_hal::WIFI_RTT_PREAMBLE_LEGACY;
1733 case RttPreamble::HT:
1734 return legacy_hal::WIFI_RTT_PREAMBLE_HT;
1735 case RttPreamble::VHT:
1736 return legacy_hal::WIFI_RTT_PREAMBLE_VHT;
1737 };
1738 CHECK(false);
1739}
1740
1741RttPreamble convertLegacyRttPreambleToHidl(legacy_hal::wifi_rtt_preamble type) {
1742 switch (type) {
1743 case legacy_hal::WIFI_RTT_PREAMBLE_LEGACY:
1744 return RttPreamble::LEGACY;
1745 case legacy_hal::WIFI_RTT_PREAMBLE_HT:
1746 return RttPreamble::HT;
1747 case legacy_hal::WIFI_RTT_PREAMBLE_VHT:
1748 return RttPreamble::VHT;
1749 };
1750 CHECK(false) << "Unknown legacy type: " << type;
1751}
1752
1753legacy_hal::wifi_rtt_bw convertHidlRttBwToLegacy(RttBw type) {
1754 switch (type) {
1755 case RttBw::BW_5MHZ:
1756 return legacy_hal::WIFI_RTT_BW_5;
1757 case RttBw::BW_10MHZ:
1758 return legacy_hal::WIFI_RTT_BW_10;
1759 case RttBw::BW_20MHZ:
1760 return legacy_hal::WIFI_RTT_BW_20;
1761 case RttBw::BW_40MHZ:
1762 return legacy_hal::WIFI_RTT_BW_40;
1763 case RttBw::BW_80MHZ:
1764 return legacy_hal::WIFI_RTT_BW_80;
1765 case RttBw::BW_160MHZ:
1766 return legacy_hal::WIFI_RTT_BW_160;
1767 };
1768 CHECK(false);
1769}
1770
1771RttBw convertLegacyRttBwToHidl(legacy_hal::wifi_rtt_bw type) {
1772 switch (type) {
1773 case legacy_hal::WIFI_RTT_BW_5:
1774 return RttBw::BW_5MHZ;
1775 case legacy_hal::WIFI_RTT_BW_10:
1776 return RttBw::BW_10MHZ;
1777 case legacy_hal::WIFI_RTT_BW_20:
1778 return RttBw::BW_20MHZ;
1779 case legacy_hal::WIFI_RTT_BW_40:
1780 return RttBw::BW_40MHZ;
1781 case legacy_hal::WIFI_RTT_BW_80:
1782 return RttBw::BW_80MHZ;
1783 case legacy_hal::WIFI_RTT_BW_160:
1784 return RttBw::BW_160MHZ;
1785 };
1786 CHECK(false) << "Unknown legacy type: " << type;
1787}
1788
1789legacy_hal::wifi_motion_pattern convertHidlRttMotionPatternToLegacy(
1790 RttMotionPattern type) {
1791 switch (type) {
1792 case RttMotionPattern::NOT_EXPECTED:
1793 return legacy_hal::WIFI_MOTION_NOT_EXPECTED;
1794 case RttMotionPattern::EXPECTED:
1795 return legacy_hal::WIFI_MOTION_EXPECTED;
1796 case RttMotionPattern::UNKNOWN:
1797 return legacy_hal::WIFI_MOTION_UNKNOWN;
1798 };
1799 CHECK(false);
1800}
1801
1802WifiRatePreamble convertLegacyWifiRatePreambleToHidl(uint8_t preamble) {
1803 switch (preamble) {
1804 case 0:
1805 return WifiRatePreamble::OFDM;
1806 case 1:
1807 return WifiRatePreamble::CCK;
1808 case 2:
1809 return WifiRatePreamble::HT;
1810 case 3:
1811 return WifiRatePreamble::VHT;
1812 default:
1813 return WifiRatePreamble::RESERVED;
1814 };
1815 CHECK(false) << "Unknown legacy preamble: " << preamble;
1816}
1817
1818WifiRateNss convertLegacyWifiRateNssToHidl(uint8_t nss) {
1819 switch (nss) {
1820 case 0:
1821 return WifiRateNss::NSS_1x1;
1822 case 1:
1823 return WifiRateNss::NSS_2x2;
1824 case 2:
1825 return WifiRateNss::NSS_3x3;
1826 case 3:
1827 return WifiRateNss::NSS_4x4;
1828 };
1829 CHECK(false) << "Unknown legacy nss: " << nss;
1830 return {};
1831}
1832
1833RttStatus convertLegacyRttStatusToHidl(legacy_hal::wifi_rtt_status status) {
1834 switch (status) {
1835 case legacy_hal::RTT_STATUS_SUCCESS:
1836 return RttStatus::SUCCESS;
1837 case legacy_hal::RTT_STATUS_FAILURE:
1838 return RttStatus::FAILURE;
1839 case legacy_hal::RTT_STATUS_FAIL_NO_RSP:
1840 return RttStatus::FAIL_NO_RSP;
1841 case legacy_hal::RTT_STATUS_FAIL_REJECTED:
1842 return RttStatus::FAIL_REJECTED;
1843 case legacy_hal::RTT_STATUS_FAIL_NOT_SCHEDULED_YET:
1844 return RttStatus::FAIL_NOT_SCHEDULED_YET;
1845 case legacy_hal::RTT_STATUS_FAIL_TM_TIMEOUT:
1846 return RttStatus::FAIL_TM_TIMEOUT;
1847 case legacy_hal::RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL:
1848 return RttStatus::FAIL_AP_ON_DIFF_CHANNEL;
1849 case legacy_hal::RTT_STATUS_FAIL_NO_CAPABILITY:
1850 return RttStatus::FAIL_NO_CAPABILITY;
1851 case legacy_hal::RTT_STATUS_ABORTED:
1852 return RttStatus::ABORTED;
1853 case legacy_hal::RTT_STATUS_FAIL_INVALID_TS:
1854 return RttStatus::FAIL_INVALID_TS;
1855 case legacy_hal::RTT_STATUS_FAIL_PROTOCOL:
1856 return RttStatus::FAIL_PROTOCOL;
1857 case legacy_hal::RTT_STATUS_FAIL_SCHEDULE:
1858 return RttStatus::FAIL_SCHEDULE;
1859 case legacy_hal::RTT_STATUS_FAIL_BUSY_TRY_LATER:
1860 return RttStatus::FAIL_BUSY_TRY_LATER;
1861 case legacy_hal::RTT_STATUS_INVALID_REQ:
1862 return RttStatus::INVALID_REQ;
1863 case legacy_hal::RTT_STATUS_NO_WIFI:
1864 return RttStatus::NO_WIFI;
1865 case legacy_hal::RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE:
1866 return RttStatus::FAIL_FTM_PARAM_OVERRIDE;
1867 };
1868 CHECK(false) << "Unknown legacy status: " << status;
1869}
1870
1871bool convertHidlWifiChannelInfoToLegacy(
1872 const WifiChannelInfo& hidl_info,
1873 legacy_hal::wifi_channel_info* legacy_info) {
1874 if (!legacy_info) {
1875 return false;
1876 }
Roshan Pius590744b2017-03-02 07:24:41 -08001877 *legacy_info = {};
Roshan Pius3fae9c82016-12-02 14:49:41 -08001878 legacy_info->width = convertHidlWifiChannelWidthToLegacy(hidl_info.width);
1879 legacy_info->center_freq = hidl_info.centerFreq;
1880 legacy_info->center_freq0 = hidl_info.centerFreq0;
1881 legacy_info->center_freq1 = hidl_info.centerFreq1;
1882 return true;
1883}
1884
1885bool convertLegacyWifiChannelInfoToHidl(
1886 const legacy_hal::wifi_channel_info& legacy_info,
1887 WifiChannelInfo* hidl_info) {
1888 if (!hidl_info) {
1889 return false;
1890 }
Roshan Pius590744b2017-03-02 07:24:41 -08001891 *hidl_info = {};
Roshan Pius3fae9c82016-12-02 14:49:41 -08001892 hidl_info->width = convertLegacyWifiChannelWidthToHidl(legacy_info.width);
1893 hidl_info->centerFreq = legacy_info.center_freq;
1894 hidl_info->centerFreq0 = legacy_info.center_freq0;
1895 hidl_info->centerFreq1 = legacy_info.center_freq1;
1896 return true;
1897}
1898
1899bool convertHidlRttConfigToLegacy(const RttConfig& hidl_config,
1900 legacy_hal::wifi_rtt_config* legacy_config) {
1901 if (!legacy_config) {
1902 return false;
1903 }
Roshan Pius590744b2017-03-02 07:24:41 -08001904 *legacy_config = {};
Roshan Pius3fae9c82016-12-02 14:49:41 -08001905 CHECK(hidl_config.addr.size() == sizeof(legacy_config->addr));
1906 memcpy(legacy_config->addr, hidl_config.addr.data(), hidl_config.addr.size());
1907 legacy_config->type = convertHidlRttTypeToLegacy(hidl_config.type);
1908 legacy_config->peer = convertHidlRttPeerTypeToLegacy(hidl_config.peer);
1909 if (!convertHidlWifiChannelInfoToLegacy(hidl_config.channel,
1910 &legacy_config->channel)) {
1911 return false;
1912 }
1913 legacy_config->burst_period = hidl_config.burstPeriod;
1914 legacy_config->num_burst = hidl_config.numBurst;
1915 legacy_config->num_frames_per_burst = hidl_config.numFramesPerBurst;
1916 legacy_config->num_retries_per_rtt_frame = hidl_config.numRetriesPerRttFrame;
1917 legacy_config->num_retries_per_ftmr = hidl_config.numRetriesPerFtmr;
1918 legacy_config->LCI_request = hidl_config.mustRequestLci;
1919 legacy_config->LCR_request = hidl_config.mustRequestLcr;
1920 legacy_config->burst_duration = hidl_config.burstDuration;
1921 legacy_config->preamble =
1922 convertHidlRttPreambleToLegacy(hidl_config.preamble);
1923 legacy_config->bw = convertHidlRttBwToLegacy(hidl_config.bw);
1924 return true;
1925}
1926
Roshan Piuse3f72ff2016-12-05 16:18:43 -08001927bool convertHidlVectorOfRttConfigToLegacy(
1928 const std::vector<RttConfig>& hidl_configs,
1929 std::vector<legacy_hal::wifi_rtt_config>* legacy_configs) {
1930 if (!legacy_configs) {
1931 return false;
1932 }
Roshan Pius590744b2017-03-02 07:24:41 -08001933 *legacy_configs = {};
Roshan Piuse3f72ff2016-12-05 16:18:43 -08001934 for (const auto& hidl_config : hidl_configs) {
1935 legacy_hal::wifi_rtt_config legacy_config;
1936 if (!convertHidlRttConfigToLegacy(hidl_config, &legacy_config)) {
1937 return false;
1938 }
1939 legacy_configs->push_back(legacy_config);
1940 }
1941 return true;
1942}
1943
Roshan Pius3fae9c82016-12-02 14:49:41 -08001944bool convertHidlRttLciInformationToLegacy(
1945 const RttLciInformation& hidl_info,
1946 legacy_hal::wifi_lci_information* legacy_info) {
1947 if (!legacy_info) {
1948 return false;
1949 }
Roshan Pius590744b2017-03-02 07:24:41 -08001950 *legacy_info = {};
Roshan Pius3fae9c82016-12-02 14:49:41 -08001951 legacy_info->latitude = hidl_info.latitude;
1952 legacy_info->longitude = hidl_info.longitude;
1953 legacy_info->altitude = hidl_info.altitude;
1954 legacy_info->latitude_unc = hidl_info.latitudeUnc;
1955 legacy_info->longitude_unc = hidl_info.longitudeUnc;
1956 legacy_info->altitude_unc = hidl_info.altitudeUnc;
1957 legacy_info->motion_pattern =
1958 convertHidlRttMotionPatternToLegacy(hidl_info.motionPattern);
1959 legacy_info->floor = hidl_info.floor;
1960 legacy_info->height_above_floor = hidl_info.heightAboveFloor;
1961 legacy_info->height_unc = hidl_info.heightUnc;
1962 return true;
1963}
1964
1965bool convertHidlRttLcrInformationToLegacy(
1966 const RttLcrInformation& hidl_info,
1967 legacy_hal::wifi_lcr_information* legacy_info) {
1968 if (!legacy_info) {
1969 return false;
1970 }
Roshan Pius590744b2017-03-02 07:24:41 -08001971 *legacy_info = {};
Roshan Pius3fae9c82016-12-02 14:49:41 -08001972 CHECK(hidl_info.countryCode.size() == sizeof(legacy_info->country_code));
1973 memcpy(legacy_info->country_code,
1974 hidl_info.countryCode.data(),
1975 hidl_info.countryCode.size());
1976 if (hidl_info.civicInfo.size() > sizeof(legacy_info->civic_info)) {
1977 return false;
1978 }
1979 legacy_info->length = hidl_info.civicInfo.size();
1980 memcpy(legacy_info->civic_info,
1981 hidl_info.civicInfo.c_str(),
1982 hidl_info.civicInfo.size());
1983 return true;
1984}
1985
1986bool convertHidlRttResponderToLegacy(
1987 const RttResponder& hidl_responder,
1988 legacy_hal::wifi_rtt_responder* legacy_responder) {
1989 if (!legacy_responder) {
1990 return false;
1991 }
Roshan Pius590744b2017-03-02 07:24:41 -08001992 *legacy_responder = {};
Roshan Pius3fae9c82016-12-02 14:49:41 -08001993 if (!convertHidlWifiChannelInfoToLegacy(hidl_responder.channel,
1994 &legacy_responder->channel)) {
1995 return false;
1996 }
1997 legacy_responder->preamble =
1998 convertHidlRttPreambleToLegacy(hidl_responder.preamble);
1999 return true;
2000}
2001
2002bool convertLegacyRttResponderToHidl(
2003 const legacy_hal::wifi_rtt_responder& legacy_responder,
2004 RttResponder* hidl_responder) {
2005 if (!hidl_responder) {
2006 return false;
2007 }
Roshan Pius590744b2017-03-02 07:24:41 -08002008 *hidl_responder = {};
Roshan Pius3fae9c82016-12-02 14:49:41 -08002009 if (!convertLegacyWifiChannelInfoToHidl(legacy_responder.channel,
2010 &hidl_responder->channel)) {
2011 return false;
2012 }
2013 hidl_responder->preamble =
2014 convertLegacyRttPreambleToHidl(legacy_responder.preamble);
2015 return true;
2016}
2017
2018bool convertLegacyRttCapabilitiesToHidl(
2019 const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
2020 RttCapabilities* hidl_capabilities) {
2021 if (!hidl_capabilities) {
2022 return false;
2023 }
Roshan Pius590744b2017-03-02 07:24:41 -08002024 *hidl_capabilities = {};
Roshan Pius3fae9c82016-12-02 14:49:41 -08002025 hidl_capabilities->rttOneSidedSupported =
2026 legacy_capabilities.rtt_one_sided_supported;
2027 hidl_capabilities->rttFtmSupported = legacy_capabilities.rtt_ftm_supported;
2028 hidl_capabilities->lciSupported = legacy_capabilities.lci_support;
2029 hidl_capabilities->lcrSupported = legacy_capabilities.lcr_support;
2030 hidl_capabilities->responderSupported =
2031 legacy_capabilities.responder_supported;
Roshan Pius88c32722017-02-16 12:43:17 -08002032 hidl_capabilities->preambleSupport = 0;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002033 for (const auto flag : {legacy_hal::WIFI_RTT_PREAMBLE_LEGACY,
2034 legacy_hal::WIFI_RTT_PREAMBLE_HT,
2035 legacy_hal::WIFI_RTT_PREAMBLE_VHT}) {
2036 if (legacy_capabilities.preamble_support & flag) {
2037 hidl_capabilities->preambleSupport |=
2038 static_cast<std::underlying_type<RttPreamble>::type>(
2039 convertLegacyRttPreambleToHidl(flag));
2040 }
2041 }
Roshan Pius88c32722017-02-16 12:43:17 -08002042 hidl_capabilities->bwSupport = 0;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002043 for (const auto flag : {legacy_hal::WIFI_RTT_BW_5,
2044 legacy_hal::WIFI_RTT_BW_10,
2045 legacy_hal::WIFI_RTT_BW_20,
2046 legacy_hal::WIFI_RTT_BW_40,
2047 legacy_hal::WIFI_RTT_BW_80,
2048 legacy_hal::WIFI_RTT_BW_160}) {
2049 if (legacy_capabilities.bw_support & flag) {
2050 hidl_capabilities->bwSupport |=
2051 static_cast<std::underlying_type<RttBw>::type>(
2052 convertLegacyRttBwToHidl(flag));
2053 }
2054 }
2055 hidl_capabilities->mcVersion = legacy_capabilities.mc_version;
2056 return true;
2057}
2058
2059bool convertLegacyWifiRateInfoToHidl(const legacy_hal::wifi_rate& legacy_rate,
2060 WifiRateInfo* hidl_rate) {
2061 if (!hidl_rate) {
2062 return false;
2063 }
Roshan Pius590744b2017-03-02 07:24:41 -08002064 *hidl_rate = {};
Roshan Pius3fae9c82016-12-02 14:49:41 -08002065 hidl_rate->preamble =
2066 convertLegacyWifiRatePreambleToHidl(legacy_rate.preamble);
2067 hidl_rate->nss = convertLegacyWifiRateNssToHidl(legacy_rate.nss);
2068 hidl_rate->bw = convertLegacyWifiChannelWidthToHidl(
2069 static_cast<legacy_hal::wifi_channel_width>(legacy_rate.bw));
2070 hidl_rate->rateMcsIdx = legacy_rate.rateMcsIdx;
2071 hidl_rate->bitRateInKbps = legacy_rate.bitrate;
2072 return true;
2073}
2074
2075bool convertLegacyRttResultToHidl(
2076 const legacy_hal::wifi_rtt_result& legacy_result, RttResult* hidl_result) {
2077 if (!hidl_result) {
2078 return false;
2079 }
Roshan Pius590744b2017-03-02 07:24:41 -08002080 *hidl_result = {};
Roshan Pius3fae9c82016-12-02 14:49:41 -08002081 CHECK(sizeof(legacy_result.addr) == hidl_result->addr.size());
2082 memcpy(
2083 hidl_result->addr.data(), legacy_result.addr, sizeof(legacy_result.addr));
2084 hidl_result->burstNum = legacy_result.burst_num;
2085 hidl_result->measurementNumber = legacy_result.measurement_number;
2086 hidl_result->successNumber = legacy_result.success_number;
2087 hidl_result->numberPerBurstPeer = legacy_result.number_per_burst_peer;
2088 hidl_result->status = convertLegacyRttStatusToHidl(legacy_result.status);
2089 hidl_result->retryAfterDuration = legacy_result.retry_after_duration;
2090 hidl_result->type = convertLegacyRttTypeToHidl(legacy_result.type);
2091 hidl_result->rssi = legacy_result.rssi;
2092 hidl_result->rssiSpread = legacy_result.rssi_spread;
2093 if (!convertLegacyWifiRateInfoToHidl(legacy_result.tx_rate,
2094 &hidl_result->txRate)) {
2095 return false;
2096 }
2097 if (!convertLegacyWifiRateInfoToHidl(legacy_result.rx_rate,
2098 &hidl_result->rxRate)) {
2099 return false;
2100 }
2101 hidl_result->rtt = legacy_result.rtt;
2102 hidl_result->rttSd = legacy_result.rtt_sd;
2103 hidl_result->rttSpread = legacy_result.rtt_spread;
2104 hidl_result->distanceInMm = legacy_result.distance_mm;
2105 hidl_result->distanceSdInMm = legacy_result.distance_sd_mm;
2106 hidl_result->distanceSpreadInMm = legacy_result.distance_spread_mm;
2107 hidl_result->timeStampInUs = legacy_result.ts;
2108 hidl_result->burstDurationInMs = legacy_result.burst_duration;
2109 hidl_result->negotiatedBurstNum = legacy_result.negotiated_burst_num;
Roshan Pius78cfef92017-03-10 21:12:11 -08002110 if (legacy_result.LCI && !convertLegacyIeToHidl(*legacy_result.LCI,
2111 &hidl_result->lci)) {
Roshan Pius3fae9c82016-12-02 14:49:41 -08002112 return false;
2113 }
Roshan Pius78cfef92017-03-10 21:12:11 -08002114 if (legacy_result.LCR && !convertLegacyIeToHidl(*legacy_result.LCR,
2115 &hidl_result->lcr)) {
Roshan Pius3fae9c82016-12-02 14:49:41 -08002116 return false;
2117 }
2118 return true;
2119}
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002120
2121bool convertLegacyVectorOfRttResultToHidl(
2122 const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
2123 std::vector<RttResult>* hidl_results) {
2124 if (!hidl_results) {
2125 return false;
2126 }
Roshan Pius590744b2017-03-02 07:24:41 -08002127 *hidl_results = {};
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002128 for (const auto legacy_result : legacy_results) {
2129 RttResult hidl_result;
2130 if (!convertLegacyRttResultToHidl(*legacy_result, &hidl_result)) {
2131 return false;
2132 }
2133 hidl_results->push_back(hidl_result);
2134 }
2135 return true;
2136}
Roshan Piuse65edb12016-11-22 13:02:01 -08002137} // namespace hidl_struct_util
2138} // namespace implementation
2139} // namespace V1_0
2140} // namespace wifi
2141} // namespace hardware
2142} // namespace android