1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
17 #include <android-base/logging.h>
18 #include <utils/SystemClock.h>
20 #include "hidl_struct_util.h"
22 namespace android {
23 namespace hardware {
24 namespace wifi {
25 namespace V1_0 {
26 namespace implementation {
27 namespace hidl_struct_util {
29 IWifiChip::ChipCapabilityMask convertLegacyLoggerFeatureToHidlChipCapability(
30 uint32_t feature) {
31 using HidlChipCaps = IWifiChip::ChipCapabilityMask;
32 switch (feature) {
33 case legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED:
34 return HidlChipCaps::DEBUG_MEMORY_FIRMWARE_DUMP;
35 case legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED:
36 return HidlChipCaps::DEBUG_MEMORY_DRIVER_DUMP;
37 case legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED:
38 return HidlChipCaps::DEBUG_RING_BUFFER_CONNECT_EVENT;
39 case legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED:
40 return HidlChipCaps::DEBUG_RING_BUFFER_POWER_EVENT;
41 case legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED:
42 return HidlChipCaps::DEBUG_RING_BUFFER_WAKELOCK_EVENT;
43 };
44 CHECK(false) << "Unknown legacy feature: " << feature;
45 return {};
46 }
48 IWifiStaIface::StaIfaceCapabilityMask
49 convertLegacyLoggerFeatureToHidlStaIfaceCapability(uint32_t feature) {
50 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
51 switch (feature) {
52 case legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED:
53 return HidlStaIfaceCaps::DEBUG_PACKET_FATE;
54 };
55 CHECK(false) << "Unknown legacy feature: " << feature;
56 return {};
57 }
59 IWifiStaIface::StaIfaceCapabilityMask
60 convertLegacyFeatureToHidlStaIfaceCapability(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;
67 case WIFI_FEATURE_RSSI_MONITOR:
68 return HidlStaIfaceCaps::RSSI_MONITOR;
69 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;
75 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;
85 case WIFI_FEATURE_CONFIG_NDO:
86 return HidlStaIfaceCaps::ND_OFFLOAD;
87 case WIFI_FEATURE_MKEEP_ALIVE:
88 return HidlStaIfaceCaps::KEEP_ALIVE;
89 };
90 CHECK(false) << "Unknown legacy feature: " << feature;
91 return {};
92 }
94 bool convertLegacyFeaturesToHidlChipCapabilities(
95 uint32_t legacy_logger_feature_set, uint32_t* hidl_caps) {
96 if (!hidl_caps) {
97 return false;
98 }
99 *hidl_caps = {};
100 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 }
110 // 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.
112 *hidl_caps |= HidlChipCaps::DEBUG_RING_BUFFER_VENDOR_DATA;
113 *hidl_caps |= HidlChipCaps::DEBUG_HOST_WAKE_REASON_STATS;
114 *hidl_caps |= HidlChipCaps::DEBUG_ERROR_ALERTS;
115 return true;
116 }
118 WifiDebugRingBufferFlags 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 }
130 bool convertLegacyDebugRingBufferStatusToHidl(
131 const legacy_hal::wifi_ring_buffer_status& legacy_status,
132 WifiDebugRingBufferStatus* hidl_status) {
133 if (!hidl_status) {
134 return false;
135 }
136 *hidl_status = {};
137 hidl_status->ringName = reinterpret_cast<const char*>(legacy_status.name);
138 hidl_status->flags = 0;
139 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 }
163 bool 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 }
169 *hidl_status_vec = {};
170 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 }
181 bool convertLegacyWakeReasonStatsToHidl(
182 const legacy_hal::WakeReasonStats& legacy_stats,
183 WifiDebugHostWakeReasonStats* hidl_stats) {
184 if (!hidl_stats) {
185 return false;
186 }
187 *hidl_stats = {};
188 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 }
225 bool 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 }
232 *hidl_caps = {};
233 *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 }
240 for (const auto feature : {WIFI_FEATURE_GSCAN,
241 WIFI_FEATURE_LINK_LAYER_STATS,
242 WIFI_FEATURE_RSSI_MONITOR,
243 WIFI_FEATURE_CONTROL_ROAMING,
244 WIFI_FEATURE_IE_WHITELIST,
245 WIFI_FEATURE_SCAN_RAND,
246 WIFI_FEATURE_INFRA_5G,
247 WIFI_FEATURE_HOTSPOT,
248 WIFI_FEATURE_PNO,
249 WIFI_FEATURE_TDLS,
250 WIFI_FEATURE_TDLS_OFFCHANNEL,
251 WIFI_FEATURE_CONFIG_NDO,
252 WIFI_FEATURE_MKEEP_ALIVE}) {
253 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 }
263 bool convertLegacyApfCapabilitiesToHidl(
264 const legacy_hal::PacketFilterCapabilities& legacy_caps,
265 StaApfPacketFilterCapabilities* hidl_caps) {
266 if (!hidl_caps) {
267 return false;
268 }
269 *hidl_caps = {};
270 hidl_caps->version = legacy_caps.version;
271 hidl_caps->maxLength = legacy_caps.max_len;
272 return true;
273 }
275 uint8_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 }
289 StaScanDataFlagMask 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 }
300 bool convertLegacyGscanCapabilitiesToHidl(
301 const legacy_hal::wifi_gscan_capabilities& legacy_caps,
302 StaBackgroundScanCapabilities* hidl_caps) {
303 if (!hidl_caps) {
304 return false;
305 }
306 *hidl_caps = {};
307 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;
312 }
314 legacy_hal::wifi_band convertHidlWifiBandToLegacy(WifiBand band) {
315 switch (band) {
316 case WifiBand::BAND_UNSPECIFIED:
317 return legacy_hal::WIFI_BAND_UNSPECIFIED;
318 case WifiBand::BAND_24GHZ:
319 return legacy_hal::WIFI_BAND_BG;
320 case WifiBand::BAND_5GHZ:
321 return legacy_hal::WIFI_BAND_A;
322 case WifiBand::BAND_5GHZ_DFS:
323 return legacy_hal::WIFI_BAND_A_DFS;
324 case WifiBand::BAND_5GHZ_WITH_DFS:
325 return legacy_hal::WIFI_BAND_A_WITH_DFS;
326 case WifiBand::BAND_24GHZ_5GHZ:
327 return legacy_hal::WIFI_BAND_ABG;
328 case WifiBand::BAND_24GHZ_5GHZ_WITH_DFS:
329 return legacy_hal::WIFI_BAND_ABG_WITH_DFS;
330 };
331 CHECK(false);
332 }
334 bool convertHidlGscanParamsToLegacy(
335 const StaBackgroundScanParameters& hidl_scan_params,
336 legacy_hal::wifi_scan_cmd_params* legacy_scan_params) {
337 if (!legacy_scan_params) {
338 return false;
339 }
340 *legacy_scan_params = {};
341 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;
347 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];
357 if (hidl_bucket_spec.bucketIdx >= MAX_BUCKETS) {
358 return false;
359 }
360 legacy_bucket_spec.bucket = hidl_bucket_spec.bucketIdx;
361 legacy_bucket_spec.band =
362 convertHidlWifiBandToLegacy(hidl_bucket_spec.band);
363 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 |=
374 convertHidlGscanReportEventFlagToLegacy(flag);
375 }
376 }
377 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 }
390 bool convertLegacyIeToHidl(
391 const legacy_hal::wifi_information_element& legacy_ie,
392 WifiInformationElement* hidl_ie) {
393 if (!hidl_ie) {
394 return false;
395 }
396 *hidl_ie = {};
397 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 }
403 bool 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 }
409 *hidl_ies = {};
410 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 LOG(ERROR) << "Error parsing IE blob. Next IE: " << (void *)next_ie
421 << ", Curr IE len: " << curr_ie_len << ", IEs End: " << (void *)ies_end;
422 break;
423 }
424 WifiInformationElement hidl_ie;
425 if (!convertLegacyIeToHidl(legacy_ie, &hidl_ie)) {
426 LOG(ERROR) << "Error converting IE. Id: " << legacy_ie.id
427 << ", len: " << legacy_ie.len;
428 break;
429 }
430 hidl_ies->push_back(std::move(hidl_ie));
431 next_ie += curr_ie_len;
432 }
433 // Check if the blob has been fully consumed.
434 if (next_ie != ies_end) {
435 LOG(ERROR) << "Failed to fully parse IE blob. Next IE: " << (void *)next_ie
436 << ", IEs End: " << (void *)ies_end;
437 }
438 return true;
439 }
441 bool convertLegacyGscanResultToHidl(
442 const legacy_hal::wifi_scan_result& legacy_scan_result,
443 bool has_ie_data,
444 StaScanResult* hidl_scan_result) {
445 if (!hidl_scan_result) {
446 return false;
447 }
448 *hidl_scan_result = {};
449 hidl_scan_result->timeStampInUs = legacy_scan_result.ts;
450 hidl_scan_result->ssid = std::vector<uint8_t>(
451 legacy_scan_result.ssid,
452 legacy_scan_result.ssid + strlen(legacy_scan_result.ssid));
453 memcpy(hidl_scan_result->bssid.data(),
454 legacy_scan_result.bssid,
455 hidl_scan_result->bssid.size());
456 hidl_scan_result->frequency = legacy_scan_result.channel;
457 hidl_scan_result->rssi = legacy_scan_result.rssi;
458 hidl_scan_result->beaconPeriodInMs = legacy_scan_result.beacon_period;
459 hidl_scan_result->capability = legacy_scan_result.capability;
460 if (has_ie_data) {
461 std::vector<WifiInformationElement> ies;
462 if (!convertLegacyIeBlobToHidl(
463 reinterpret_cast<const uint8_t*>(legacy_scan_result.ie_data),
464 legacy_scan_result.ie_length,
465 &ies)) {
466 return false;
467 }
468 hidl_scan_result->informationElements = std::move(ies);
469 }
470 return true;
471 }
473 bool convertLegacyCachedGscanResultsToHidl(
474 const legacy_hal::wifi_cached_scan_results& legacy_cached_scan_result,
475 StaScanData* hidl_scan_data) {
476 if (!hidl_scan_data) {
477 return false;
478 }
479 *hidl_scan_data = {};
480 hidl_scan_data->flags = 0;
481 for (const auto flag : {legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED}) {
482 if (legacy_cached_scan_result.flags & flag) {
483 hidl_scan_data->flags |=
484 static_cast<std::underlying_type<StaScanDataFlagMask>::type>(
485 convertLegacyGscanDataFlagToHidl(flag));
486 }
487 }
488 hidl_scan_data->bucketsScanned = legacy_cached_scan_result.buckets_scanned;
490 CHECK(legacy_cached_scan_result.num_results >= 0 &&
491 legacy_cached_scan_result.num_results <= MAX_AP_CACHE_PER_SCAN);
492 std::vector<StaScanResult> hidl_scan_results;
493 for (int32_t result_idx = 0;
494 result_idx < legacy_cached_scan_result.num_results;
495 result_idx++) {
496 StaScanResult hidl_scan_result;
497 if (!convertLegacyGscanResultToHidl(
498 legacy_cached_scan_result.results[result_idx],
499 false,
500 &hidl_scan_result)) {
501 return false;
502 }
503 hidl_scan_results.push_back(hidl_scan_result);
504 }
505 hidl_scan_data->results = std::move(hidl_scan_results);
506 return true;
507 }
509 bool convertLegacyVectorOfCachedGscanResultsToHidl(
510 const std::vector<legacy_hal::wifi_cached_scan_results>&
511 legacy_cached_scan_results,
512 std::vector<StaScanData>* hidl_scan_datas) {
513 if (!hidl_scan_datas) {
514 return false;
515 }
516 *hidl_scan_datas = {};
517 for (const auto& legacy_cached_scan_result : legacy_cached_scan_results) {
518 StaScanData hidl_scan_data;
519 if (!convertLegacyCachedGscanResultsToHidl(legacy_cached_scan_result,
520 &hidl_scan_data)) {
521 return false;
522 }
523 hidl_scan_datas->push_back(hidl_scan_data);
524 }
525 return true;
526 }
528 WifiDebugTxPacketFate convertLegacyDebugTxPacketFateToHidl(
529 legacy_hal::wifi_tx_packet_fate fate) {
530 switch (fate) {
531 case legacy_hal::TX_PKT_FATE_ACKED:
532 return WifiDebugTxPacketFate::ACKED;
533 case legacy_hal::TX_PKT_FATE_SENT:
534 return WifiDebugTxPacketFate::SENT;
535 case legacy_hal::TX_PKT_FATE_FW_QUEUED:
536 return WifiDebugTxPacketFate::FW_QUEUED;
537 case legacy_hal::TX_PKT_FATE_FW_DROP_INVALID:
538 return WifiDebugTxPacketFate::FW_DROP_INVALID;
539 case legacy_hal::TX_PKT_FATE_FW_DROP_NOBUFS:
540 return WifiDebugTxPacketFate::FW_DROP_NOBUFS;
541 case legacy_hal::TX_PKT_FATE_FW_DROP_OTHER:
542 return WifiDebugTxPacketFate::FW_DROP_OTHER;
543 case legacy_hal::TX_PKT_FATE_DRV_QUEUED:
544 return WifiDebugTxPacketFate::DRV_QUEUED;
545 case legacy_hal::TX_PKT_FATE_DRV_DROP_INVALID:
546 return WifiDebugTxPacketFate::DRV_DROP_INVALID;
547 case legacy_hal::TX_PKT_FATE_DRV_DROP_NOBUFS:
548 return WifiDebugTxPacketFate::DRV_DROP_NOBUFS;
549 case legacy_hal::TX_PKT_FATE_DRV_DROP_OTHER:
550 return WifiDebugTxPacketFate::DRV_DROP_OTHER;
551 };
552 CHECK(false) << "Unknown legacy fate type: " << fate;
553 }
555 WifiDebugRxPacketFate convertLegacyDebugRxPacketFateToHidl(
556 legacy_hal::wifi_rx_packet_fate fate) {
557 switch (fate) {
558 case legacy_hal::RX_PKT_FATE_SUCCESS:
559 return WifiDebugRxPacketFate::SUCCESS;
560 case legacy_hal::RX_PKT_FATE_FW_QUEUED:
561 return WifiDebugRxPacketFate::FW_QUEUED;
562 case legacy_hal::RX_PKT_FATE_FW_DROP_FILTER:
563 return WifiDebugRxPacketFate::FW_DROP_FILTER;
564 case legacy_hal::RX_PKT_FATE_FW_DROP_INVALID:
565 return WifiDebugRxPacketFate::FW_DROP_INVALID;
566 case legacy_hal::RX_PKT_FATE_FW_DROP_NOBUFS:
567 return WifiDebugRxPacketFate::FW_DROP_NOBUFS;
568 case legacy_hal::RX_PKT_FATE_FW_DROP_OTHER:
569 return WifiDebugRxPacketFate::FW_DROP_OTHER;
570 case legacy_hal::RX_PKT_FATE_DRV_QUEUED:
571 return WifiDebugRxPacketFate::DRV_QUEUED;
572 case legacy_hal::RX_PKT_FATE_DRV_DROP_FILTER:
573 return WifiDebugRxPacketFate::DRV_DROP_FILTER;
574 case legacy_hal::RX_PKT_FATE_DRV_DROP_INVALID:
575 return WifiDebugRxPacketFate::DRV_DROP_INVALID;
576 case legacy_hal::RX_PKT_FATE_DRV_DROP_NOBUFS:
577 return WifiDebugRxPacketFate::DRV_DROP_NOBUFS;
578 case legacy_hal::RX_PKT_FATE_DRV_DROP_OTHER:
579 return WifiDebugRxPacketFate::DRV_DROP_OTHER;
580 };
581 CHECK(false) << "Unknown legacy fate type: " << fate;
582 }
584 WifiDebugPacketFateFrameType convertLegacyDebugPacketFateFrameTypeToHidl(
585 legacy_hal::frame_type type) {
586 switch (type) {
587 case legacy_hal::FRAME_TYPE_UNKNOWN:
588 return WifiDebugPacketFateFrameType::UNKNOWN;
589 case legacy_hal::FRAME_TYPE_ETHERNET_II:
590 return WifiDebugPacketFateFrameType::ETHERNET_II;
591 case legacy_hal::FRAME_TYPE_80211_MGMT:
592 return WifiDebugPacketFateFrameType::MGMT_80211;
593 };
594 CHECK(false) << "Unknown legacy frame type: " << type;
595 }
597 bool convertLegacyDebugPacketFateFrameToHidl(
598 const legacy_hal::frame_info& legacy_frame,
599 WifiDebugPacketFateFrameInfo* hidl_frame) {
600 if (!hidl_frame) {
601 return false;
602 }
603 *hidl_frame = {};
604 hidl_frame->frameType =
605 convertLegacyDebugPacketFateFrameTypeToHidl(legacy_frame.payload_type);
606 hidl_frame->frameLen = legacy_frame.frame_len;
607 hidl_frame->driverTimestampUsec = legacy_frame.driver_timestamp_usec;
608 hidl_frame->firmwareTimestampUsec = legacy_frame.firmware_timestamp_usec;
609 const uint8_t* frame_begin = reinterpret_cast<const uint8_t*>(
610 legacy_frame.frame_content.ethernet_ii_bytes);
611 hidl_frame->frameContent =
612 std::vector<uint8_t>(frame_begin, frame_begin + legacy_frame.frame_len);
613 return true;
614 }
616 bool convertLegacyDebugTxPacketFateToHidl(
617 const legacy_hal::wifi_tx_report& legacy_fate,
618 WifiDebugTxPacketFateReport* hidl_fate) {
619 if (!hidl_fate) {
620 return false;
621 }
622 *hidl_fate = {};
623 hidl_fate->fate = convertLegacyDebugTxPacketFateToHidl(legacy_fate.fate);
624 return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
625 &hidl_fate->frameInfo);
626 }
628 bool convertLegacyVectorOfDebugTxPacketFateToHidl(
629 const std::vector<legacy_hal::wifi_tx_report>& legacy_fates,
630 std::vector<WifiDebugTxPacketFateReport>* hidl_fates) {
631 if (!hidl_fates) {
632 return false;
633 }
634 *hidl_fates = {};
635 for (const auto& legacy_fate : legacy_fates) {
636 WifiDebugTxPacketFateReport hidl_fate;
637 if (!convertLegacyDebugTxPacketFateToHidl(legacy_fate, &hidl_fate)) {
638 return false;
639 }
640 hidl_fates->push_back(hidl_fate);
641 }
642 return true;
643 }
645 bool convertLegacyDebugRxPacketFateToHidl(
646 const legacy_hal::wifi_rx_report& legacy_fate,
647 WifiDebugRxPacketFateReport* hidl_fate) {
648 if (!hidl_fate) {
649 return false;
650 }
651 *hidl_fate = {};
652 hidl_fate->fate = convertLegacyDebugRxPacketFateToHidl(legacy_fate.fate);
653 return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
654 &hidl_fate->frameInfo);
655 }
657 bool convertLegacyVectorOfDebugRxPacketFateToHidl(
658 const std::vector<legacy_hal::wifi_rx_report>& legacy_fates,
659 std::vector<WifiDebugRxPacketFateReport>* hidl_fates) {
660 if (!hidl_fates) {
661 return false;
662 }
663 *hidl_fates = {};
664 for (const auto& legacy_fate : legacy_fates) {
665 WifiDebugRxPacketFateReport hidl_fate;
666 if (!convertLegacyDebugRxPacketFateToHidl(legacy_fate, &hidl_fate)) {
667 return false;
668 }
669 hidl_fates->push_back(hidl_fate);
670 }
671 return true;
672 }
674 bool convertLegacyLinkLayerStatsToHidl(
675 const legacy_hal::LinkLayerStats& legacy_stats,
676 StaLinkLayerStats* hidl_stats) {
677 if (!hidl_stats) {
678 return false;
679 }
680 *hidl_stats = {};
681 // iface legacy_stats conversion.
682 hidl_stats->iface.beaconRx = legacy_stats.iface.beacon_rx;
683 hidl_stats->iface.avgRssiMgmt = legacy_stats.iface.rssi_mgmt;
684 hidl_stats->iface.wmeBePktStats.rxMpdu =
685 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu;
686 hidl_stats->iface.wmeBePktStats.txMpdu =
687 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu;
688 hidl_stats->iface.wmeBePktStats.lostMpdu =
689 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost;
690 hidl_stats->iface.wmeBePktStats.retries =
691 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries;
692 hidl_stats->iface.wmeBkPktStats.rxMpdu =
693 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu;
694 hidl_stats->iface.wmeBkPktStats.txMpdu =
695 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu;
696 hidl_stats->iface.wmeBkPktStats.lostMpdu =
697 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost;
698 hidl_stats->iface.wmeBkPktStats.retries =
699 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries;
700 hidl_stats->iface.wmeViPktStats.rxMpdu =
701 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu;
702 hidl_stats->iface.wmeViPktStats.txMpdu =
703 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu;
704 hidl_stats->iface.wmeViPktStats.lostMpdu =
705 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost;
706 hidl_stats->iface.wmeViPktStats.retries =
707 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries;
708 hidl_stats->iface.wmeVoPktStats.rxMpdu =
709 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu;
710 hidl_stats->iface.wmeVoPktStats.txMpdu =
711 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu;
712 hidl_stats->iface.wmeVoPktStats.lostMpdu =
713 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost;
714 hidl_stats->iface.wmeVoPktStats.retries =
715 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries;
716 // radio legacy_stats conversion.
717 std::vector<StaLinkLayerRadioStats> hidl_radios_stats;
718 for (const auto& legacy_radio_stats : legacy_stats.radios) {
719 StaLinkLayerRadioStats hidl_radio_stats;
720 hidl_radio_stats.onTimeInMs = legacy_radio_stats.stats.on_time;
721 hidl_radio_stats.txTimeInMs = legacy_radio_stats.stats.tx_time;
722 hidl_radio_stats.rxTimeInMs = legacy_radio_stats.stats.rx_time;
723 hidl_radio_stats.onTimeInMsForScan = legacy_radio_stats.stats.on_time_scan;
724 hidl_radio_stats.txTimeInMsPerLevel = legacy_radio_stats.tx_time_per_levels;
725 hidl_radios_stats.push_back(hidl_radio_stats);
726 }
727 hidl_stats->radios = hidl_radios_stats;
728 // Timestamp in the HAL wrapper here since it's not provided in the legacy
729 // HAL API.
730 hidl_stats->timeStampInMs = uptimeMillis();
731 return true;
732 }
734 bool convertLegacyRoamingCapabilitiesToHidl(
735 const legacy_hal::wifi_roaming_capabilities& legacy_caps,
736 StaRoamingCapabilities* hidl_caps) {
737 if (!hidl_caps) {
738 return false;
739 }
740 *hidl_caps = {};
741 hidl_caps->maxBlacklistSize = legacy_caps.max_blacklist_size;
742 hidl_caps->maxWhitelistSize = legacy_caps.max_whitelist_size;
743 return true;
744 }
746 bool convertHidlRoamingConfigToLegacy(
747 const StaRoamingConfig& hidl_config,
748 legacy_hal::wifi_roaming_config* legacy_config) {
749 if (!legacy_config) {
750 return false;
751 }
752 *legacy_config = {};
753 if (hidl_config.bssidBlacklist.size() > MAX_BLACKLIST_BSSID ||
754 hidl_config.ssidWhitelist.size() > MAX_WHITELIST_SSID) {
755 return false;
756 }
757 legacy_config->num_blacklist_bssid = hidl_config.bssidBlacklist.size();
758 uint32_t i = 0;
759 for (const auto& bssid : hidl_config.bssidBlacklist) {
760 CHECK(bssid.size() == sizeof(legacy_hal::mac_addr));
761 memcpy(legacy_config->blacklist_bssid[i++], bssid.data(), bssid.size());
762 }
763 legacy_config->num_whitelist_ssid = hidl_config.ssidWhitelist.size();
764 i = 0;
765 for (const auto& ssid : hidl_config.ssidWhitelist) {
766 CHECK(ssid.size() <= sizeof(legacy_hal::ssid_t::ssid_str));
767 legacy_config->whitelist_ssid[i].length = ssid.size();
768 memcpy(legacy_config->whitelist_ssid[i].ssid_str, ssid.data(), ssid.size());
769 i++;
770 }
771 return true;
772 }
774 legacy_hal::fw_roaming_state_t convertHidlRoamingStateToLegacy(
775 StaRoamingState state) {
776 switch (state) {
777 case StaRoamingState::ENABLED:
778 return legacy_hal::ROAMING_ENABLE;
779 case StaRoamingState::DISABLED:
780 return legacy_hal::ROAMING_DISABLE;
781 };
782 CHECK(false);
783 }
785 legacy_hal::NanMatchAlg convertHidlNanMatchAlgToLegacy(NanMatchAlg type) {
786 switch (type) {
787 case NanMatchAlg::MATCH_ONCE:
788 return legacy_hal::NAN_MATCH_ALG_MATCH_ONCE;
789 case NanMatchAlg::MATCH_CONTINUOUS:
790 return legacy_hal::NAN_MATCH_ALG_MATCH_CONTINUOUS;
791 case NanMatchAlg::MATCH_NEVER:
792 return legacy_hal::NAN_MATCH_ALG_MATCH_NEVER;
793 }
794 CHECK(false);
795 }
797 legacy_hal::NanPublishType convertHidlNanPublishTypeToLegacy(NanPublishType type) {
798 switch (type) {
799 case NanPublishType::UNSOLICITED:
800 return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED;
801 case NanPublishType::SOLICITED:
802 return legacy_hal::NAN_PUBLISH_TYPE_SOLICITED;
803 case NanPublishType::UNSOLICITED_SOLICITED:
804 return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
805 }
806 CHECK(false);
807 }
809 legacy_hal::NanTxType convertHidlNanTxTypeToLegacy(NanTxType type) {
810 switch (type) {
811 case NanTxType::BROADCAST:
812 return legacy_hal::NAN_TX_TYPE_BROADCAST;
813 case NanTxType::UNICAST:
814 return legacy_hal::NAN_TX_TYPE_UNICAST;
815 }
816 CHECK(false);
817 }
819 legacy_hal::NanSubscribeType convertHidlNanSubscribeTypeToLegacy(NanSubscribeType type) {
820 switch (type) {
821 case NanSubscribeType::PASSIVE:
822 return legacy_hal::NAN_SUBSCRIBE_TYPE_PASSIVE;
823 case NanSubscribeType::ACTIVE:
824 return legacy_hal::NAN_SUBSCRIBE_TYPE_ACTIVE;
825 }
826 CHECK(false);
827 }
829 legacy_hal::NanSRFType convertHidlNanSrfTypeToLegacy(NanSrfType type) {
830 switch (type) {
831 case NanSrfType::BLOOM_FILTER:
832 return legacy_hal::NAN_SRF_ATTR_BLOOM_FILTER;
833 case NanSrfType::PARTIAL_MAC_ADDR:
834 return legacy_hal::NAN_SRF_ATTR_PARTIAL_MAC_ADDR;
835 }
836 CHECK(false);
837 }
839 legacy_hal::NanDataPathChannelCfg convertHidlNanDataPathChannelCfgToLegacy(
840 NanDataPathChannelCfg type) {
841 switch (type) {
842 case NanDataPathChannelCfg::CHANNEL_NOT_REQUESTED:
843 return legacy_hal::NAN_DP_CHANNEL_NOT_REQUESTED;
844 case NanDataPathChannelCfg::REQUEST_CHANNEL_SETUP:
845 return legacy_hal::NAN_DP_REQUEST_CHANNEL_SETUP;
846 case NanDataPathChannelCfg::FORCE_CHANNEL_SETUP:
847 return legacy_hal::NAN_DP_FORCE_CHANNEL_SETUP;
848 }
849 CHECK(false);
850 }
852 NanStatusType convertLegacyNanStatusTypeToHidl(
853 legacy_hal::NanStatusType type) {
854 switch (type) {
855 case legacy_hal::NAN_STATUS_SUCCESS:
856 return NanStatusType::SUCCESS;
857 case legacy_hal::NAN_STATUS_INTERNAL_FAILURE:
858 return NanStatusType::INTERNAL_FAILURE;
859 case legacy_hal::NAN_STATUS_PROTOCOL_FAILURE:
860 return NanStatusType::PROTOCOL_FAILURE;
861 case legacy_hal::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID:
862 return NanStatusType::INVALID_SESSION_ID;
863 case legacy_hal::NAN_STATUS_NO_RESOURCE_AVAILABLE:
864 return NanStatusType::NO_RESOURCES_AVAILABLE;
865 case legacy_hal::NAN_STATUS_INVALID_PARAM:
866 return NanStatusType::INVALID_ARGS;
867 case legacy_hal::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID:
868 return NanStatusType::INVALID_PEER_ID;
869 case legacy_hal::NAN_STATUS_INVALID_NDP_ID:
870 return NanStatusType::INVALID_NDP_ID;
871 case legacy_hal::NAN_STATUS_NAN_NOT_ALLOWED:
872 return NanStatusType::NAN_NOT_ALLOWED;
873 case legacy_hal::NAN_STATUS_NO_OTA_ACK:
874 return NanStatusType::NO_OTA_ACK;
875 case legacy_hal::NAN_STATUS_ALREADY_ENABLED:
876 return NanStatusType::ALREADY_ENABLED;
877 case legacy_hal::NAN_STATUS_FOLLOWUP_QUEUE_FULL:
878 return NanStatusType::FOLLOWUP_TX_QUEUE_FULL;
879 case legacy_hal::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED:
880 return NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED;
881 }
882 CHECK(false);
883 }
885 bool convertHidlNanEnableRequestToLegacy(
886 const NanEnableRequest& hidl_request,
887 legacy_hal::NanEnableRequest* legacy_request) {
888 if (!legacy_request) {
889 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: null legacy_request";
890 return false;
891 }
892 *legacy_request = {};
894 legacy_request->config_2dot4g_support = 1;
895 legacy_request->support_2dot4g_val = hidl_request.operateInBand[
896 (size_t) NanBandIndex::NAN_BAND_24GHZ];
897 legacy_request->config_support_5g = 1;
898 legacy_request->support_5g_val = hidl_request.operateInBand[(size_t) NanBandIndex::NAN_BAND_5GHZ];
899 legacy_request->config_hop_count_limit = 1;
900 legacy_request->hop_count_limit_val = hidl_request.hopCountMax;
901 legacy_request->master_pref = hidl_request.configParams.masterPref;
902 legacy_request->discovery_indication_cfg = 0;
903 legacy_request->discovery_indication_cfg |=
904 hidl_request.configParams.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
905 legacy_request->discovery_indication_cfg |=
906 hidl_request.configParams.disableStartedClusterIndication ? 0x2 : 0x0;
907 legacy_request->discovery_indication_cfg |=
908 hidl_request.configParams.disableJoinedClusterIndication ? 0x4 : 0x0;
909 legacy_request->config_sid_beacon = 1;
910 if (hidl_request.configParams.numberOfPublishServiceIdsInBeacon > 127) {
911 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: numberOfPublishServiceIdsInBeacon > 127";
912 return false;
913 }
914 legacy_request->sid_beacon_val =
915 (hidl_request.configParams.includePublishServiceIdsInBeacon ? 0x1 : 0x0)
916 | (hidl_request.configParams.numberOfPublishServiceIdsInBeacon << 1);
917 // TODO: b/35195516 connect SubscribeServiceIds to legacy HAL once implemented
918 legacy_request->config_rssi_window_size = 1;
919 legacy_request->rssi_window_size_val = hidl_request.configParams.rssiWindowSize;
920 legacy_request->config_disc_mac_addr_randomization = 1;
921 legacy_request->disc_mac_addr_rand_interval_sec =
922 hidl_request.configParams.macAddressRandomizationIntervalSec;
923 legacy_request->config_2dot4g_rssi_close = 1;
924 if (hidl_request.configParams.bandSpecificConfig.size() != 2) {
925 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: bandSpecificConfig.size() != 2";
926 return false;
927 }
928 legacy_request->rssi_close_2dot4g_val =
929 hidl_request.configParams.bandSpecificConfig[
930 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiClose;
931 legacy_request->config_2dot4g_rssi_middle = 1;
932 legacy_request->rssi_middle_2dot4g_val =
933 hidl_request.configParams.bandSpecificConfig[
934 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiMiddle;
935 legacy_request->config_2dot4g_rssi_proximity = 1;
936 legacy_request->rssi_proximity_2dot4g_val =
937 hidl_request.configParams.bandSpecificConfig[
938 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiCloseProximity;
939 legacy_request->config_scan_params = 1;
940 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
941 hidl_request.configParams.bandSpecificConfig[
942 (size_t) NanBandIndex::NAN_BAND_24GHZ].dwellTimeMs;
943 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
944 hidl_request.configParams.bandSpecificConfig[
945 (size_t) NanBandIndex::NAN_BAND_24GHZ].scanPeriodSec;
946 legacy_request->config_dw.config_2dot4g_dw_band = hidl_request.configParams
947 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].validDiscoveryWindowIntervalVal;
948 legacy_request->config_dw.dw_2dot4g_interval_val = hidl_request.configParams
949 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].discoveryWindowIntervalVal;
950 legacy_request->config_5g_rssi_close = 1;
951 legacy_request->rssi_close_5g_val =
952 hidl_request.configParams.bandSpecificConfig[
953 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiClose;
954 legacy_request->config_5g_rssi_middle = 1;
955 legacy_request->rssi_middle_5g_val =
956 hidl_request.configParams.bandSpecificConfig[
957 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiMiddle;
958 legacy_request->config_5g_rssi_close_proximity = 1;
959 legacy_request->rssi_close_proximity_5g_val =
960 hidl_request.configParams.bandSpecificConfig[
961 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiCloseProximity;
962 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
963 hidl_request.configParams.bandSpecificConfig[
964 (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
965 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
966 hidl_request.configParams.bandSpecificConfig[
967 (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
968 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
969 hidl_request.configParams.bandSpecificConfig[
970 (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
971 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
972 hidl_request.configParams.bandSpecificConfig[
973 (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
974 legacy_request->config_dw.config_5g_dw_band = hidl_request.configParams
975 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].validDiscoveryWindowIntervalVal;
976 legacy_request->config_dw.dw_5g_interval_val = hidl_request.configParams
977 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].discoveryWindowIntervalVal;
978 if (hidl_request.debugConfigs.validClusterIdVals) {
979 legacy_request->cluster_low = hidl_request.debugConfigs.clusterIdBottomRangeVal;
980 legacy_request->cluster_high = hidl_request.debugConfigs.clusterIdTopRangeVal;
981 } else { // need 'else' since not configurable in legacy HAL
982 legacy_request->cluster_low = 0x0000;
983 legacy_request->cluster_high = 0xFFFF;
984 }
985 legacy_request->config_intf_addr = hidl_request.debugConfigs.validIntfAddrVal;
986 memcpy(legacy_request->intf_addr_val, hidl_request.debugConfigs.intfAddrVal.data(), 6);
987 legacy_request->config_oui = hidl_request.debugConfigs.validOuiVal;
988 legacy_request->oui_val = hidl_request.debugConfigs.ouiVal;
989 legacy_request->config_random_factor_force = hidl_request.debugConfigs.validRandomFactorForceVal;
990 legacy_request->random_factor_force_val = hidl_request.debugConfigs.randomFactorForceVal;
991 legacy_request->config_hop_count_force = hidl_request.debugConfigs.validHopCountForceVal;
992 legacy_request->hop_count_force_val = hidl_request.debugConfigs.hopCountForceVal;
993 legacy_request->config_24g_channel = hidl_request.debugConfigs.validDiscoveryChannelVal;
994 legacy_request->channel_24g_val =
995 hidl_request.debugConfigs.discoveryChannelMhzVal[(size_t) NanBandIndex::NAN_BAND_24GHZ];
996 legacy_request->config_5g_channel = hidl_request.debugConfigs.validDiscoveryChannelVal;
997 legacy_request->channel_5g_val = hidl_request.debugConfigs
998 .discoveryChannelMhzVal[(size_t) NanBandIndex::NAN_BAND_5GHZ];
999 legacy_request->config_2dot4g_beacons = hidl_request.debugConfigs.validUseBeaconsInBandVal;
1000 legacy_request->beacon_2dot4g_val = hidl_request.debugConfigs
1001 .useBeaconsInBandVal[(size_t) NanBandIndex::NAN_BAND_24GHZ];
1002 legacy_request->config_5g_beacons = hidl_request.debugConfigs.validUseBeaconsInBandVal;
1003 legacy_request->beacon_5g_val = hidl_request.debugConfigs
1004 .useBeaconsInBandVal[(size_t) NanBandIndex::NAN_BAND_5GHZ];
1005 legacy_request->config_2dot4g_sdf = hidl_request.debugConfigs.validUseSdfInBandVal;
1006 legacy_request->sdf_2dot4g_val = hidl_request.debugConfigs
1007 .useSdfInBandVal[(size_t) NanBandIndex::NAN_BAND_24GHZ];
1008 legacy_request->config_5g_sdf = hidl_request.debugConfigs.validUseSdfInBandVal;
1009 legacy_request->sdf_5g_val = hidl_request.debugConfigs
1010 .useSdfInBandVal[(size_t) NanBandIndex::NAN_BAND_5GHZ];
1012 return true;
1013 }
1015 bool convertHidlNanPublishRequestToLegacy(
1016 const NanPublishRequest& hidl_request,
1017 legacy_hal::NanPublishRequest* legacy_request) {
1018 if (!legacy_request) {
1019 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: null legacy_request";
1020 return false;
1021 }
1022 *legacy_request = {};
1024 legacy_request->publish_id = hidl_request.baseConfigs.sessionId;
1025 legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
1026 legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
1027 legacy_request->publish_count = hidl_request.baseConfigs.discoveryCount;
1028 legacy_request->service_name_len = hidl_request.baseConfigs.serviceName.size();
1029 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1030 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: service_name_len too large";
1031 return false;
1032 }
1033 memcpy(legacy_request->service_name, hidl_request.baseConfigs.serviceName.data(),
1034 legacy_request->service_name_len);
1035 legacy_request->publish_match_indicator =
1036 convertHidlNanMatchAlgToLegacy(hidl_request.baseConfigs.discoveryMatchIndicator);
1037 legacy_request->service_specific_info_len = hidl_request.baseConfigs.serviceSpecificInfo.size();
1038 if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1039 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: service_specific_info_len too large";
1040 return false;
1041 }
1042 memcpy(legacy_request->service_specific_info,
1043 hidl_request.baseConfigs.serviceSpecificInfo.data(),
1044 legacy_request->service_specific_info_len);
1045 legacy_request->sdea_service_specific_info_len =
1046 hidl_request.baseConfigs.extendedServiceSpecificInfo.size();
1047 if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1048 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: sdea_service_specific_info_len too large";
1049 return false;
1050 }
1051 memcpy(legacy_request->sdea_service_specific_info,
1052 hidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
1053 legacy_request->sdea_service_specific_info_len);
1054 legacy_request->rx_match_filter_len = hidl_request.baseConfigs.rxMatchFilter.size();
1055 if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1056 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: rx_match_filter_len too large";
1057 return false;
1058 }
1059 memcpy(legacy_request->rx_match_filter,
1060 hidl_request.baseConfigs.rxMatchFilter.data(),
1061 legacy_request->rx_match_filter_len);
1062 legacy_request->tx_match_filter_len = hidl_request.baseConfigs.txMatchFilter.size();
1063 if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1064 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: tx_match_filter_len too large";
1065 return false;
1066 }
1067 memcpy(legacy_request->tx_match_filter,
1068 hidl_request.baseConfigs.txMatchFilter.data(),
1069 legacy_request->tx_match_filter_len);
1070 legacy_request->rssi_threshold_flag = hidl_request.baseConfigs.useRssiThreshold;
1071 legacy_request->recv_indication_cfg = 0;
1072 legacy_request->recv_indication_cfg |=
1073 hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1 : 0x0;
1074 legacy_request->recv_indication_cfg |=
1075 hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
1076 legacy_request->recv_indication_cfg |=
1077 hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
1078 legacy_request->recv_indication_cfg |= 0x8;
1079 legacy_request->cipher_type = (unsigned int) hidl_request.baseConfigs.securityConfig.cipherType;
1080 if (hidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PMK) {
1081 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1082 legacy_request->key_info.body.pmk_info.pmk_len =
1083 hidl_request.baseConfigs.securityConfig.pmk.size();
1084 if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
1085 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: invalid pmk_len";
1086 return false;
1087 }
1088 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1089 hidl_request.baseConfigs.securityConfig.pmk.data(),
1090 legacy_request->key_info.body.pmk_info.pmk_len);
1091 }
1092 if (hidl_request.baseConfigs.securityConfig.securityType
1093 == NanDataPathSecurityType::PASSPHRASE) {
1094 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1095 legacy_request->key_info.body.passphrase_info.passphrase_len =
1096 hidl_request.baseConfigs.securityConfig.passphrase.size();
1097 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1098 < NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1099 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: passphrase_len too small";
1100 return false;
1101 }
1102 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1103 > NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1104 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: passphrase_len too large";
1105 return false;
1106 }
1107 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1108 hidl_request.baseConfigs.securityConfig.passphrase.data(),
1109 legacy_request->key_info.body.passphrase_info.passphrase_len);
1110 }
1111 legacy_request->sdea_params.security_cfg = (hidl_request.baseConfigs.securityConfig.securityType
1112 != NanDataPathSecurityType::OPEN) ? legacy_hal::NAN_DP_CONFIG_SECURITY
1113 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
1114 legacy_request->sdea_params.ranging_state = hidl_request.baseConfigs.rangingRequired ?
1115 legacy_hal::NAN_RANGING_ENABLE : legacy_hal::NAN_RANGING_DISABLE;
1116 legacy_request->ranging_cfg.ranging_interval_msec = hidl_request.baseConfigs.rangingIntervalMsec;
1117 legacy_request->ranging_cfg.config_ranging_indications =
1118 hidl_request.baseConfigs.configRangingIndications;
1119 legacy_request->ranging_cfg.distance_ingress_cm = hidl_request.baseConfigs.distanceIngressCm;
1120 legacy_request->ranging_cfg.distance_egress_cm = hidl_request.baseConfigs.distanceEgressCm;
1121 legacy_request->ranging_auto_response = hidl_request.baseConfigs.rangingRequired ?
1122 legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
1123 legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT;
1124 legacy_request->publish_type = convertHidlNanPublishTypeToLegacy(hidl_request.publishType);
1125 legacy_request->tx_type = convertHidlNanTxTypeToLegacy(hidl_request.txType);
1126 legacy_request->service_responder_policy = hidl_request.autoAcceptDataPathRequests ?
1127 legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL : legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE;
1129 return true;
1130 }
1132 bool convertHidlNanSubscribeRequestToLegacy(
1133 const NanSubscribeRequest& hidl_request,
1134 legacy_hal::NanSubscribeRequest* legacy_request) {
1135 if (!legacy_request) {
1136 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: legacy_request is null";
1137 return false;
1138 }
1139 *legacy_request = {};
1141 legacy_request->subscribe_id = hidl_request.baseConfigs.sessionId;
1142 legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
1143 legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
1144 legacy_request->subscribe_count = hidl_request.baseConfigs.discoveryCount;
1145 legacy_request->service_name_len = hidl_request.baseConfigs.serviceName.size();
1146 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1147 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: service_name_len too large";
1148 return false;
1149 }
1150 memcpy(legacy_request->service_name, hidl_request.baseConfigs.serviceName.data(),
1151 legacy_request->service_name_len);
1152 legacy_request->subscribe_match_indicator =
1153 convertHidlNanMatchAlgToLegacy(hidl_request.baseConfigs.discoveryMatchIndicator);
1154 legacy_request->service_specific_info_len = hidl_request.baseConfigs.serviceSpecificInfo.size();
1155 if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1156 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: service_specific_info_len too large";
1157 return false;
1158 }
1159 memcpy(legacy_request->service_specific_info,
1160 hidl_request.baseConfigs.serviceSpecificInfo.data(),
1161 legacy_request->service_specific_info_len);
1162 legacy_request->sdea_service_specific_info_len =
1163 hidl_request.baseConfigs.extendedServiceSpecificInfo.size();
1164 if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1165 LOG(ERROR) <<
1166 "convertHidlNanSubscribeRequestToLegacy: sdea_service_specific_info_len too large";
1167 return false;
1168 }
1169 memcpy(legacy_request->sdea_service_specific_info,
1170 hidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
1171 legacy_request->sdea_service_specific_info_len);
1172 legacy_request->rx_match_filter_len = hidl_request.baseConfigs.rxMatchFilter.size();
1173 if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1174 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: rx_match_filter_len too large";
1175 return false;
1176 }
1177 memcpy(legacy_request->rx_match_filter,
1178 hidl_request.baseConfigs.rxMatchFilter.data(),
1179 legacy_request->rx_match_filter_len);
1180 legacy_request->tx_match_filter_len = hidl_request.baseConfigs.txMatchFilter.size();
1181 if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1182 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: tx_match_filter_len too large";
1183 return false;
1184 }
1185 memcpy(legacy_request->tx_match_filter,
1186 hidl_request.baseConfigs.txMatchFilter.data(),
1187 legacy_request->tx_match_filter_len);
1188 legacy_request->rssi_threshold_flag = hidl_request.baseConfigs.useRssiThreshold;
1189 legacy_request->recv_indication_cfg = 0;
1190 legacy_request->recv_indication_cfg |=
1191 hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1 : 0x0;
1192 legacy_request->recv_indication_cfg |=
1193 hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
1194 legacy_request->recv_indication_cfg |=
1195 hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
1196 legacy_request->cipher_type = (unsigned int) hidl_request.baseConfigs.securityConfig.cipherType;
1197 if (hidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PMK) {
1198 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1199 legacy_request->key_info.body.pmk_info.pmk_len =
1200 hidl_request.baseConfigs.securityConfig.pmk.size();
1201 if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
1202 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: invalid pmk_len";
1203 return false;
1204 }
1205 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1206 hidl_request.baseConfigs.securityConfig.pmk.data(),
1207 legacy_request->key_info.body.pmk_info.pmk_len);
1208 }
1209 if (hidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) {
1210 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1211 legacy_request->key_info.body.passphrase_info.passphrase_len =
1212 hidl_request.baseConfigs.securityConfig.passphrase.size();
1213 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1214 < NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1215 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: passphrase_len too small";
1216 return false;
1217 }
1218 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1219 > NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1220 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: passphrase_len too large";
1221 return false;
1222 }
1223 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1224 hidl_request.baseConfigs.securityConfig.passphrase.data(),
1225 legacy_request->key_info.body.passphrase_info.passphrase_len);
1226 }
1227 legacy_request->sdea_params.security_cfg = (hidl_request.baseConfigs.securityConfig.securityType
1228 != NanDataPathSecurityType::OPEN) ? legacy_hal::NAN_DP_CONFIG_SECURITY
1229 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
1230 legacy_request->sdea_params.ranging_state = hidl_request.baseConfigs.rangingRequired ?
1231 legacy_hal::NAN_RANGING_ENABLE : legacy_hal::NAN_RANGING_DISABLE;
1232 legacy_request->ranging_cfg.ranging_interval_msec = hidl_request.baseConfigs.rangingIntervalMsec;
1233 legacy_request->ranging_cfg.config_ranging_indications =
1234 hidl_request.baseConfigs.configRangingIndications;
1235 legacy_request->ranging_cfg.distance_ingress_cm = hidl_request.baseConfigs.distanceIngressCm;
1236 legacy_request->ranging_cfg.distance_egress_cm = hidl_request.baseConfigs.distanceEgressCm;
1237 legacy_request->ranging_auto_response = hidl_request.baseConfigs.rangingRequired ?
1238 legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
1239 legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT;
1240 legacy_request->subscribe_type = convertHidlNanSubscribeTypeToLegacy(hidl_request.subscribeType);
1241 legacy_request->serviceResponseFilter = convertHidlNanSrfTypeToLegacy(hidl_request.srfType);
1242 legacy_request->serviceResponseInclude = hidl_request.srfRespondIfInAddressSet ?
1243 legacy_hal::NAN_SRF_INCLUDE_RESPOND : legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
1244 legacy_request->useServiceResponseFilter = hidl_request.shouldUseSrf ?
1245 legacy_hal::NAN_USE_SRF : legacy_hal::NAN_DO_NOT_USE_SRF;
1246 legacy_request->ssiRequiredForMatchIndication = hidl_request.isSsiRequiredForMatch ?
1247 legacy_hal::NAN_SSI_REQUIRED_IN_MATCH_IND : legacy_hal::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND;
1248 legacy_request->num_intf_addr_present = hidl_request.intfAddr.size();
1249 if (legacy_request->num_intf_addr_present > NAN_MAX_SUBSCRIBE_MAX_ADDRESS) {
1250 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: num_intf_addr_present - too many";
1251 return false;
1252 }
1253 for (int i = 0; i < legacy_request->num_intf_addr_present; i++) {
1254 memcpy(legacy_request->intf_addr[i], hidl_request.intfAddr[i].data(), 6);
1255 }
1257 return true;
1258 }
1260 bool convertHidlNanTransmitFollowupRequestToLegacy(
1261 const NanTransmitFollowupRequest& hidl_request,
1262 legacy_hal::NanTransmitFollowupRequest* legacy_request) {
1263 if (!legacy_request) {
1264 LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: legacy_request is null";
1265 return false;
1266 }
1267 *legacy_request = {};
1269 legacy_request->publish_subscribe_id = hidl_request.discoverySessionId;
1270 legacy_request->requestor_instance_id = hidl_request.peerId;
1271 memcpy(legacy_request->addr, hidl_request.addr.data(), 6);
1272 legacy_request->priority = hidl_request.isHighPriority ?
1273 legacy_hal::NAN_TX_PRIORITY_HIGH : legacy_hal::NAN_TX_PRIORITY_NORMAL;
1274 legacy_request->dw_or_faw = hidl_request.shouldUseDiscoveryWindow ?
1275 legacy_hal::NAN_TRANSMIT_IN_DW : legacy_hal::NAN_TRANSMIT_IN_FAW;
1276 legacy_request->service_specific_info_len = hidl_request.serviceSpecificInfo.size();
1277 if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1278 LOG(ERROR) <<
1279 "convertHidlNanTransmitFollowupRequestToLegacy: service_specific_info_len too large";
1280 return false;
1281 }
1282 memcpy(legacy_request->service_specific_info,
1283 hidl_request.serviceSpecificInfo.data(),
1284 legacy_request->service_specific_info_len);
1285 legacy_request->sdea_service_specific_info_len = hidl_request.extendedServiceSpecificInfo.size();
1286 if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1287 LOG(ERROR) <<
1288 "convertHidlNanTransmitFollowupRequestToLegacy: sdea_service_specific_info_len too large";
1289 return false;
1290 }
1291 memcpy(legacy_request->sdea_service_specific_info,
1292 hidl_request.extendedServiceSpecificInfo.data(),
1293 legacy_request->sdea_service_specific_info_len);
1294 legacy_request->recv_indication_cfg = hidl_request.disableFollowupResultIndication ? 0x1 : 0x0;
1296 return true;
1297 }
1299 bool convertHidlNanConfigRequestToLegacy(
1300 const NanConfigRequest& hidl_request,
1301 legacy_hal::NanConfigRequest* legacy_request) {
1302 if (!legacy_request) {
1303 LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: legacy_request is null";
1304 return false;
1305 }
1306 *legacy_request = {};
1308 // TODO: b/34059183 tracks missing configurations in legacy HAL or uknown defaults
1309 legacy_request->master_pref = hidl_request.masterPref;
1310 legacy_request->discovery_indication_cfg = 0;
1311 legacy_request->discovery_indication_cfg |=
1312 hidl_request.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
1313 legacy_request->discovery_indication_cfg |=
1314 hidl_request.disableStartedClusterIndication ? 0x2 : 0x0;
1315 legacy_request->discovery_indication_cfg |=
1316 hidl_request.disableJoinedClusterIndication ? 0x4 : 0x0;
1317 legacy_request->config_sid_beacon = 1;
1318 if (hidl_request.numberOfPublishServiceIdsInBeacon > 127) {
1319 LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: numberOfPublishServiceIdsInBeacon > 127";
1320 return false;
1321 }
1322 legacy_request->sid_beacon = (hidl_request.includePublishServiceIdsInBeacon ? 0x1 : 0x0)
1323 | (hidl_request.numberOfPublishServiceIdsInBeacon << 1);
1324 // TODO: b/35195516 connect SubscribeServiceIds to legacy HAL once implemented
1325 legacy_request->config_rssi_window_size = 1;
1326 legacy_request->rssi_window_size_val = hidl_request.rssiWindowSize;
1327 legacy_request->config_disc_mac_addr_randomization = 1;
1328 legacy_request->disc_mac_addr_rand_interval_sec =
1329 hidl_request.macAddressRandomizationIntervalSec;
1330 /* TODO : missing
1331 legacy_request->config_2dot4g_rssi_close = 1;
1332 legacy_request->rssi_close_2dot4g_val =
1333 hidl_request.bandSpecificConfig[
1334 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiClose;
1335 legacy_request->config_2dot4g_rssi_middle = 1;
1336 legacy_request->rssi_middle_2dot4g_val =
1337 hidl_request.bandSpecificConfig[
1338 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiMiddle;
1339 legacy_request->config_2dot4g_rssi_proximity = 1;
1340 legacy_request->rssi_proximity_2dot4g_val =
1341 hidl_request.bandSpecificConfig[
1342 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiCloseProximity;
1343 */
1344 legacy_request->config_scan_params = 1;
1345 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
1346 hidl_request.bandSpecificConfig[
1347 (size_t) NanBandIndex::NAN_BAND_24GHZ].dwellTimeMs;
1348 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
1349 hidl_request.bandSpecificConfig[
1350 (size_t) NanBandIndex::NAN_BAND_24GHZ].scanPeriodSec;
1351 legacy_request->config_dw.config_2dot4g_dw_band = hidl_request
1352 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].validDiscoveryWindowIntervalVal;
1353 legacy_request->config_dw.dw_2dot4g_interval_val = hidl_request
1354 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].discoveryWindowIntervalVal;
1355 /* TODO: missing
1356 legacy_request->config_5g_rssi_close = 1;
1357 legacy_request->rssi_close_5g_val =
1358 hidl_request.bandSpecificConfig[
1359 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiClose;
1360 legacy_request->config_5g_rssi_middle = 1;
1361 legacy_request->rssi_middle_5g_val =
1362 hidl_request.bandSpecificConfig[
1363 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiMiddle;
1364 */
1365 legacy_request->config_5g_rssi_close_proximity = 1;
1366 legacy_request->rssi_close_proximity_5g_val =
1367 hidl_request.bandSpecificConfig[
1368 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiCloseProximity;
1369 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1370 hidl_request.bandSpecificConfig[
1371 (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
1372 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1373 hidl_request.bandSpecificConfig[
1374 (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
1375 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1376 hidl_request.bandSpecificConfig[
1377 (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
1378 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1379 hidl_request.bandSpecificConfig[
1380 (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
1381 legacy_request->config_dw.config_5g_dw_band = hidl_request
1382 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].validDiscoveryWindowIntervalVal;
1383 legacy_request->config_dw.dw_5g_interval_val = hidl_request
1384 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].discoveryWindowIntervalVal;
1386 return true;
1387 }
1389 bool convertHidlNanDataPathInitiatorRequestToLegacy(
1390 const NanInitiateDataPathRequest& hidl_request,
1391 legacy_hal::NanDataPathInitiatorRequest* legacy_request) {
1392 if (!legacy_request) {
1393 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: legacy_request is null";
1394 return false;
1395 }
1396 *legacy_request = {};
1398 legacy_request->requestor_instance_id = hidl_request.peerId;
1399 memcpy(legacy_request->peer_disc_mac_addr, hidl_request.peerDiscMacAddr.data(), 6);
1400 legacy_request->channel_request_type =
1401 convertHidlNanDataPathChannelCfgToLegacy(hidl_request.channelRequestType);
1402 legacy_request->channel = hidl_request.channel;
1403 strcpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str());
1404 legacy_request->ndp_cfg.security_cfg = (hidl_request.securityConfig.securityType
1405 != NanDataPathSecurityType::OPEN) ? legacy_hal::NAN_DP_CONFIG_SECURITY
1406 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
1407 legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
1408 if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
1409 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: ndp_app_info_len too large";
1410 return false;
1411 }
1412 memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
1413 legacy_request->app_info.ndp_app_info_len);
1414 legacy_request->cipher_type = (unsigned int) hidl_request.securityConfig.cipherType;
1415 if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PMK) {
1416 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1417 legacy_request->key_info.body.pmk_info.pmk_len = hidl_request.securityConfig.pmk.size();
1418 if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
1419 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: invalid pmk_len";
1420 return false;
1421 }
1422 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1423 hidl_request.securityConfig.pmk.data(),
1424 legacy_request->key_info.body.pmk_info.pmk_len);
1425 }
1426 if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) {
1427 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1428 legacy_request->key_info.body.passphrase_info.passphrase_len =
1429 hidl_request.securityConfig.passphrase.size();
1430 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1431 < NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1432 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: passphrase_len too small";
1433 return false;
1434 }
1435 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1436 > NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1437 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: passphrase_len too large";
1438 return false;
1439 }
1440 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1441 hidl_request.securityConfig.passphrase.data(),
1442 legacy_request->key_info.body.passphrase_info.passphrase_len);
1443 }
1444 legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
1445 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1446 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: service_name_len too large";
1447 return false;
1448 }
1449 memcpy(legacy_request->service_name, hidl_request.serviceNameOutOfBand.data(),
1450 legacy_request->service_name_len);
1452 return true;
1453 }
1455 bool convertHidlNanDataPathIndicationResponseToLegacy(
1456 const NanRespondToDataPathIndicationRequest& hidl_request,
1457 legacy_hal::NanDataPathIndicationResponse* legacy_request) {
1458 if (!legacy_request) {
1459 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: legacy_request is null";
1460 return false;
1461 }
1462 *legacy_request = {};
1464 legacy_request->rsp_code = hidl_request.acceptRequest ?
1465 legacy_hal::NAN_DP_REQUEST_ACCEPT : legacy_hal::NAN_DP_REQUEST_REJECT;
1466 legacy_request->ndp_instance_id = hidl_request.ndpInstanceId;
1467 strcpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str());
1468 legacy_request->ndp_cfg.security_cfg = (hidl_request.securityConfig.securityType
1469 != NanDataPathSecurityType::OPEN) ? legacy_hal::NAN_DP_CONFIG_SECURITY
1470 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
1471 legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
1472 if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
1473 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: ndp_app_info_len too large";
1474 return false;
1475 }
1476 memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
1477 legacy_request->app_info.ndp_app_info_len);
1478 legacy_request->cipher_type = (unsigned int) hidl_request.securityConfig.cipherType;
1479 if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PMK) {
1480 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1481 legacy_request->key_info.body.pmk_info.pmk_len = hidl_request.securityConfig.pmk.size();
1482 if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
1483 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: invalid pmk_len";
1484 return false;
1485 }
1486 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1487 hidl_request.securityConfig.pmk.data(),
1488 legacy_request->key_info.body.pmk_info.pmk_len);
1489 }
1490 if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) {
1491 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1492 legacy_request->key_info.body.passphrase_info.passphrase_len =
1493 hidl_request.securityConfig.passphrase.size();
1494 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1495 < NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1496 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: passphrase_len too small";
1497 return false;
1498 }
1499 if (legacy_request->key_info.body.passphrase_info.passphrase_len
1500 > NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1501 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: passphrase_len too large";
1502 return false;
1503 }
1504 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1505 hidl_request.securityConfig.passphrase.data(),
1506 legacy_request->key_info.body.passphrase_info.passphrase_len);
1507 }
1508 legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
1509 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1510 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: service_name_len too large";
1511 return false;
1512 }
1513 memcpy(legacy_request->service_name, hidl_request.serviceNameOutOfBand.data(),
1514 legacy_request->service_name_len);
1516 return true;
1517 }
1519 bool convertLegacyNanResponseHeaderToHidl(
1520 const legacy_hal::NanResponseMsg& legacy_response,
1521 WifiNanStatus* wifiNanStatus) {
1522 if (!wifiNanStatus) {
1523 LOG(ERROR) << "convertLegacyNanResponseHeaderToHidl: wifiNanStatus is null";
1524 return false;
1525 }
1526 *wifiNanStatus = {};
1528 wifiNanStatus->status = convertLegacyNanStatusTypeToHidl(legacy_response.status);
1529 wifiNanStatus->description = legacy_response.nan_error;
1530 return true;
1531 }
1533 bool convertLegacyNanCapabilitiesResponseToHidl(
1534 const legacy_hal::NanCapabilities& legacy_response,
1535 NanCapabilities* hidl_response) {
1536 if (!hidl_response) {
1537 LOG(ERROR) << "convertLegacyNanCapabilitiesResponseToHidl: hidl_response is null";
1538 return false;
1539 }
1540 *hidl_response = {};
1542 hidl_response->maxConcurrentClusters = legacy_response.max_concurrent_nan_clusters;
1543 hidl_response->maxPublishes = legacy_response.max_publishes;
1544 hidl_response->maxSubscribes = legacy_response.max_subscribes;
1545 hidl_response->maxServiceNameLen = legacy_response.max_service_name_len;
1546 hidl_response->maxMatchFilterLen = legacy_response.max_match_filter_len;
1547 hidl_response->maxTotalMatchFilterLen = legacy_response.max_total_match_filter_len;
1548 hidl_response->maxServiceSpecificInfoLen = legacy_response.max_service_specific_info_len;
1549 hidl_response->maxExtendedServiceSpecificInfoLen =
1550 legacy_response.max_sdea_service_specific_info_len;
1551 hidl_response->maxNdiInterfaces = legacy_response.max_ndi_interfaces;
1552 hidl_response->maxNdpSessions = legacy_response.max_ndp_sessions;
1553 hidl_response->maxAppInfoLen = legacy_response.max_app_info_len;
1554 hidl_response->maxQueuedTransmitFollowupMsgs = legacy_response.max_queued_transmit_followup_msgs;
1555 hidl_response->maxSubscribeInterfaceAddresses = legacy_response.max_subscribe_address;
1556 hidl_response->supportedCipherSuites = legacy_response.cipher_suites_supported;
1558 return true;
1559 }
1561 bool convertLegacyNanMatchIndToHidl(
1562 const legacy_hal::NanMatchInd& legacy_ind,
1563 NanMatchInd* hidl_ind) {
1564 if (!hidl_ind) {
1565 LOG(ERROR) << "convertLegacyNanMatchIndToHidl: hidl_ind is null";
1566 return false;
1567 }
1568 *hidl_ind = {};
1570 hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
1571 hidl_ind->peerId = legacy_ind.requestor_instance_id;
1572 hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
1573 hidl_ind->serviceSpecificInfo = std::vector<uint8_t>(legacy_ind.service_specific_info,
1574 legacy_ind.service_specific_info + legacy_ind.service_specific_info_len);
1575 hidl_ind->extendedServiceSpecificInfo = std::vector<uint8_t>(
1576 legacy_ind.sdea_service_specific_info,
1577 legacy_ind.sdea_service_specific_info + legacy_ind.sdea_service_specific_info_len);
1578 hidl_ind->matchFilter = std::vector<uint8_t>(legacy_ind.sdf_match_filter,
1579 legacy_ind.sdf_match_filter + legacy_ind.sdf_match_filter_len);
1580 hidl_ind->matchOccuredInBeaconFlag = legacy_ind.match_occured_flag == 1;
1581 hidl_ind->outOfResourceFlag = legacy_ind.out_of_resource_flag == 1;
1582 hidl_ind->rssiValue = legacy_ind.rssi_value;
1583 hidl_ind->peerCipherType = (NanCipherSuiteType) legacy_ind.peer_cipher_type;
1584 hidl_ind->peerRequiresSecurityEnabledInNdp =
1585 legacy_ind.peer_sdea_params.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
1586 hidl_ind->peerRequiresRanging =
1587 legacy_ind.peer_sdea_params.ranging_state == legacy_hal::NAN_RANGING_ENABLE;
1588 hidl_ind->rangingMeasurementInCm = legacy_ind.range_info.range_measurement_cm;
1589 hidl_ind->rangingIndicationType = legacy_ind.range_info.ranging_event_type;
1591 return true;
1592 }
1594 bool convertLegacyNanFollowupIndToHidl(
1595 const legacy_hal::NanFollowupInd& legacy_ind,
1596 NanFollowupReceivedInd* hidl_ind) {
1597 if (!hidl_ind) {
1598 LOG(ERROR) << "convertLegacyNanFollowupIndToHidl: hidl_ind is null";
1599 return false;
1600 }
1601 *hidl_ind = {};
1603 hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
1604 hidl_ind->peerId = legacy_ind.requestor_instance_id;
1605 hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
1606 hidl_ind->receivedInFaw = legacy_ind.dw_or_faw == 1;
1607 hidl_ind->serviceSpecificInfo = std::vector<uint8_t>(legacy_ind.service_specific_info,
1608 legacy_ind.service_specific_info + legacy_ind.service_specific_info_len);
1609 hidl_ind->extendedServiceSpecificInfo = std::vector<uint8_t>(
1610 legacy_ind.sdea_service_specific_info,
1611 legacy_ind.sdea_service_specific_info + legacy_ind.sdea_service_specific_info_len);
1613 return true;
1614 }
1616 bool convertLegacyNanDataPathRequestIndToHidl(
1617 const legacy_hal::NanDataPathRequestInd& legacy_ind,
1618 NanDataPathRequestInd* hidl_ind) {
1619 if (!hidl_ind) {
1620 LOG(ERROR) << "convertLegacyNanDataPathRequestIndToHidl: hidl_ind is null";
1621 return false;
1622 }
1623 *hidl_ind = {};
1625 hidl_ind->discoverySessionId = legacy_ind.service_instance_id;
1626 hidl_ind->peerDiscMacAddr = hidl_array<uint8_t, 6>(legacy_ind.peer_disc_mac_addr);
1627 hidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
1628 hidl_ind->securityRequired =
1629 legacy_ind.ndp_cfg.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
1630 hidl_ind->appInfo = std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info,
1631 legacy_ind.app_info.ndp_app_info + legacy_ind.app_info.ndp_app_info_len);
1633 return true;
1634 }
1636 bool convertLegacyNanDataPathConfirmIndToHidl(
1637 const legacy_hal::NanDataPathConfirmInd& legacy_ind,
1638 NanDataPathConfirmInd* hidl_ind) {
1639 if (!hidl_ind) {
1640 LOG(ERROR) << "convertLegacyNanDataPathConfirmIndToHidl: hidl_ind is null";
1641 return false;
1642 }
1643 *hidl_ind = {};
1645 hidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
1646 hidl_ind->dataPathSetupSuccess = legacy_ind.rsp_code == legacy_hal::NAN_DP_REQUEST_ACCEPT;
1647 hidl_ind->peerNdiMacAddr = hidl_array<uint8_t, 6>(legacy_ind.peer_ndi_mac_addr);
1648 hidl_ind->appInfo = std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info,
1649 legacy_ind.app_info.ndp_app_info + legacy_ind.app_info.ndp_app_info_len);
1650 hidl_ind->status.status = convertLegacyNanStatusTypeToHidl(legacy_ind.reason_code);
1651 hidl_ind->status.description = ""; // TODO: b/34059183
1653 return true;
1654 }
1656 legacy_hal::wifi_rtt_type convertHidlRttTypeToLegacy(RttType type) {
1657 switch (type) {
1658 case RttType::ONE_SIDED:
1659 return legacy_hal::RTT_TYPE_1_SIDED;
1660 case RttType::TWO_SIDED:
1661 return legacy_hal::RTT_TYPE_2_SIDED;
1662 };
1663 CHECK(false);
1664 }
1666 RttType convertLegacyRttTypeToHidl(legacy_hal::wifi_rtt_type type) {
1667 switch (type) {
1668 case legacy_hal::RTT_TYPE_1_SIDED:
1669 return RttType::ONE_SIDED;
1670 case legacy_hal::RTT_TYPE_2_SIDED:
1671 return RttType::TWO_SIDED;
1672 };
1673 CHECK(false) << "Unknown legacy type: " << type;
1674 }
1676 legacy_hal::rtt_peer_type convertHidlRttPeerTypeToLegacy(RttPeerType type) {
1677 switch (type) {
1678 case RttPeerType::AP:
1679 return legacy_hal::RTT_PEER_AP;
1680 case RttPeerType::STA:
1681 return legacy_hal::RTT_PEER_STA;
1682 case RttPeerType::P2P_GO:
1683 return legacy_hal::RTT_PEER_P2P_GO;
1684 case RttPeerType::P2P_CLIENT:
1685 return legacy_hal::RTT_PEER_P2P_CLIENT;
1686 case RttPeerType::NAN:
1687 return legacy_hal::RTT_PEER_NAN;
1688 };
1689 CHECK(false);
1690 }
1692 legacy_hal::wifi_channel_width convertHidlWifiChannelWidthToLegacy(
1693 WifiChannelWidthInMhz type) {
1694 switch (type) {
1695 case WifiChannelWidthInMhz::WIDTH_20:
1696 return legacy_hal::WIFI_CHAN_WIDTH_20;
1697 case WifiChannelWidthInMhz::WIDTH_40:
1698 return legacy_hal::WIFI_CHAN_WIDTH_40;
1699 case WifiChannelWidthInMhz::WIDTH_80:
1700 return legacy_hal::WIFI_CHAN_WIDTH_80;
1701 case WifiChannelWidthInMhz::WIDTH_160:
1702 return legacy_hal::WIFI_CHAN_WIDTH_160;
1703 case WifiChannelWidthInMhz::WIDTH_80P80:
1704 return legacy_hal::WIFI_CHAN_WIDTH_80P80;
1705 case WifiChannelWidthInMhz::WIDTH_5:
1706 return legacy_hal::WIFI_CHAN_WIDTH_5;
1707 case WifiChannelWidthInMhz::WIDTH_10:
1708 return legacy_hal::WIFI_CHAN_WIDTH_10;
1709 case WifiChannelWidthInMhz::WIDTH_INVALID:
1710 return legacy_hal::WIFI_CHAN_WIDTH_INVALID;
1711 };
1712 CHECK(false);
1713 }
1715 WifiChannelWidthInMhz convertLegacyWifiChannelWidthToHidl(
1716 legacy_hal::wifi_channel_width type) {
1717 switch (type) {
1718 case legacy_hal::WIFI_CHAN_WIDTH_20:
1719 return WifiChannelWidthInMhz::WIDTH_20;
1720 case legacy_hal::WIFI_CHAN_WIDTH_40:
1721 return WifiChannelWidthInMhz::WIDTH_40;
1722 case legacy_hal::WIFI_CHAN_WIDTH_80:
1723 return WifiChannelWidthInMhz::WIDTH_80;
1724 case legacy_hal::WIFI_CHAN_WIDTH_160:
1725 return WifiChannelWidthInMhz::WIDTH_160;
1726 case legacy_hal::WIFI_CHAN_WIDTH_80P80:
1727 return WifiChannelWidthInMhz::WIDTH_80P80;
1728 case legacy_hal::WIFI_CHAN_WIDTH_5:
1729 return WifiChannelWidthInMhz::WIDTH_5;
1730 case legacy_hal::WIFI_CHAN_WIDTH_10:
1731 return WifiChannelWidthInMhz::WIDTH_10;
1732 case legacy_hal::WIFI_CHAN_WIDTH_INVALID:
1733 return WifiChannelWidthInMhz::WIDTH_INVALID;
1734 };
1735 CHECK(false) << "Unknown legacy type: " << type;
1736 }
1738 legacy_hal::wifi_rtt_preamble convertHidlRttPreambleToLegacy(RttPreamble type) {
1739 switch (type) {
1740 case RttPreamble::LEGACY:
1741 return legacy_hal::WIFI_RTT_PREAMBLE_LEGACY;
1742 case RttPreamble::HT:
1743 return legacy_hal::WIFI_RTT_PREAMBLE_HT;
1744 case RttPreamble::VHT:
1745 return legacy_hal::WIFI_RTT_PREAMBLE_VHT;
1746 };
1747 CHECK(false);
1748 }
1750 RttPreamble convertLegacyRttPreambleToHidl(legacy_hal::wifi_rtt_preamble type) {
1751 switch (type) {
1752 case legacy_hal::WIFI_RTT_PREAMBLE_LEGACY:
1753 return RttPreamble::LEGACY;
1754 case legacy_hal::WIFI_RTT_PREAMBLE_HT:
1755 return RttPreamble::HT;
1756 case legacy_hal::WIFI_RTT_PREAMBLE_VHT:
1757 return RttPreamble::VHT;
1758 };
1759 CHECK(false) << "Unknown legacy type: " << type;
1760 }
1762 legacy_hal::wifi_rtt_bw convertHidlRttBwToLegacy(RttBw type) {
1763 switch (type) {
1764 case RttBw::BW_5MHZ:
1765 return legacy_hal::WIFI_RTT_BW_5;
1766 case RttBw::BW_10MHZ:
1767 return legacy_hal::WIFI_RTT_BW_10;
1768 case RttBw::BW_20MHZ:
1769 return legacy_hal::WIFI_RTT_BW_20;
1770 case RttBw::BW_40MHZ:
1771 return legacy_hal::WIFI_RTT_BW_40;
1772 case RttBw::BW_80MHZ:
1773 return legacy_hal::WIFI_RTT_BW_80;
1774 case RttBw::BW_160MHZ:
1775 return legacy_hal::WIFI_RTT_BW_160;
1776 };
1777 CHECK(false);
1778 }
1780 RttBw convertLegacyRttBwToHidl(legacy_hal::wifi_rtt_bw type) {
1781 switch (type) {
1782 case legacy_hal::WIFI_RTT_BW_5:
1783 return RttBw::BW_5MHZ;
1784 case legacy_hal::WIFI_RTT_BW_10:
1785 return RttBw::BW_10MHZ;
1786 case legacy_hal::WIFI_RTT_BW_20:
1787 return RttBw::BW_20MHZ;
1788 case legacy_hal::WIFI_RTT_BW_40:
1789 return RttBw::BW_40MHZ;
1790 case legacy_hal::WIFI_RTT_BW_80:
1791 return RttBw::BW_80MHZ;
1792 case legacy_hal::WIFI_RTT_BW_160:
1793 return RttBw::BW_160MHZ;
1794 };
1795 CHECK(false) << "Unknown legacy type: " << type;
1796 }
1798 legacy_hal::wifi_motion_pattern convertHidlRttMotionPatternToLegacy(
1799 RttMotionPattern type) {
1800 switch (type) {
1801 case RttMotionPattern::NOT_EXPECTED:
1802 return legacy_hal::WIFI_MOTION_NOT_EXPECTED;
1803 case RttMotionPattern::EXPECTED:
1804 return legacy_hal::WIFI_MOTION_EXPECTED;
1805 case RttMotionPattern::UNKNOWN:
1806 return legacy_hal::WIFI_MOTION_UNKNOWN;
1807 };
1808 CHECK(false);
1809 }
1811 WifiRatePreamble convertLegacyWifiRatePreambleToHidl(uint8_t preamble) {
1812 switch (preamble) {
1813 case 0:
1814 return WifiRatePreamble::OFDM;
1815 case 1:
1816 return WifiRatePreamble::CCK;
1817 case 2:
1818 return WifiRatePreamble::HT;
1819 case 3:
1820 return WifiRatePreamble::VHT;
1821 default:
1822 return WifiRatePreamble::RESERVED;
1823 };
1824 CHECK(false) << "Unknown legacy preamble: " << preamble;
1825 }
1827 WifiRateNss convertLegacyWifiRateNssToHidl(uint8_t nss) {
1828 switch (nss) {
1829 case 0:
1830 return WifiRateNss::NSS_1x1;
1831 case 1:
1832 return WifiRateNss::NSS_2x2;
1833 case 2:
1834 return WifiRateNss::NSS_3x3;
1835 case 3:
1836 return WifiRateNss::NSS_4x4;
1837 };
1838 CHECK(false) << "Unknown legacy nss: " << nss;
1839 return {};
1840 }
1842 RttStatus convertLegacyRttStatusToHidl(legacy_hal::wifi_rtt_status status) {
1843 switch (status) {
1844 case legacy_hal::RTT_STATUS_SUCCESS:
1845 return RttStatus::SUCCESS;
1846 case legacy_hal::RTT_STATUS_FAILURE:
1847 return RttStatus::FAILURE;
1848 case legacy_hal::RTT_STATUS_FAIL_NO_RSP:
1849 return RttStatus::FAIL_NO_RSP;
1850 case legacy_hal::RTT_STATUS_FAIL_REJECTED:
1851 return RttStatus::FAIL_REJECTED;
1852 case legacy_hal::RTT_STATUS_FAIL_NOT_SCHEDULED_YET:
1853 return RttStatus::FAIL_NOT_SCHEDULED_YET;
1854 case legacy_hal::RTT_STATUS_FAIL_TM_TIMEOUT:
1855 return RttStatus::FAIL_TM_TIMEOUT;
1856 case legacy_hal::RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL:
1857 return RttStatus::FAIL_AP_ON_DIFF_CHANNEL;
1858 case legacy_hal::RTT_STATUS_FAIL_NO_CAPABILITY:
1859 return RttStatus::FAIL_NO_CAPABILITY;
1860 case legacy_hal::RTT_STATUS_ABORTED:
1861 return RttStatus::ABORTED;
1862 case legacy_hal::RTT_STATUS_FAIL_INVALID_TS:
1863 return RttStatus::FAIL_INVALID_TS;
1864 case legacy_hal::RTT_STATUS_FAIL_PROTOCOL:
1865 return RttStatus::FAIL_PROTOCOL;
1866 case legacy_hal::RTT_STATUS_FAIL_SCHEDULE:
1867 return RttStatus::FAIL_SCHEDULE;
1868 case legacy_hal::RTT_STATUS_FAIL_BUSY_TRY_LATER:
1869 return RttStatus::FAIL_BUSY_TRY_LATER;
1870 case legacy_hal::RTT_STATUS_INVALID_REQ:
1871 return RttStatus::INVALID_REQ;
1872 case legacy_hal::RTT_STATUS_NO_WIFI:
1873 return RttStatus::NO_WIFI;
1874 case legacy_hal::RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE:
1875 return RttStatus::FAIL_FTM_PARAM_OVERRIDE;
1876 };
1877 CHECK(false) << "Unknown legacy status: " << status;
1878 }
1880 bool convertHidlWifiChannelInfoToLegacy(
1881 const WifiChannelInfo& hidl_info,
1882 legacy_hal::wifi_channel_info* legacy_info) {
1883 if (!legacy_info) {
1884 return false;
1885 }
1886 *legacy_info = {};
1887 legacy_info->width = convertHidlWifiChannelWidthToLegacy(hidl_info.width);
1888 legacy_info->center_freq = hidl_info.centerFreq;
1889 legacy_info->center_freq0 = hidl_info.centerFreq0;
1890 legacy_info->center_freq1 = hidl_info.centerFreq1;
1891 return true;
1892 }
1894 bool convertLegacyWifiChannelInfoToHidl(
1895 const legacy_hal::wifi_channel_info& legacy_info,
1896 WifiChannelInfo* hidl_info) {
1897 if (!hidl_info) {
1898 return false;
1899 }
1900 *hidl_info = {};
1901 hidl_info->width = convertLegacyWifiChannelWidthToHidl(legacy_info.width);
1902 hidl_info->centerFreq = legacy_info.center_freq;
1903 hidl_info->centerFreq0 = legacy_info.center_freq0;
1904 hidl_info->centerFreq1 = legacy_info.center_freq1;
1905 return true;
1906 }
1908 bool convertHidlRttConfigToLegacy(const RttConfig& hidl_config,
1909 legacy_hal::wifi_rtt_config* legacy_config) {
1910 if (!legacy_config) {
1911 return false;
1912 }
1913 *legacy_config = {};
1914 CHECK(hidl_config.addr.size() == sizeof(legacy_config->addr));
1915 memcpy(legacy_config->addr, hidl_config.addr.data(), hidl_config.addr.size());
1916 legacy_config->type = convertHidlRttTypeToLegacy(hidl_config.type);
1917 legacy_config->peer = convertHidlRttPeerTypeToLegacy(hidl_config.peer);
1918 if (!convertHidlWifiChannelInfoToLegacy(hidl_config.channel,
1919 &legacy_config->channel)) {
1920 return false;
1921 }
1922 legacy_config->burst_period = hidl_config.burstPeriod;
1923 legacy_config->num_burst = hidl_config.numBurst;
1924 legacy_config->num_frames_per_burst = hidl_config.numFramesPerBurst;
1925 legacy_config->num_retries_per_rtt_frame = hidl_config.numRetriesPerRttFrame;
1926 legacy_config->num_retries_per_ftmr = hidl_config.numRetriesPerFtmr;
1927 legacy_config->LCI_request = hidl_config.mustRequestLci;
1928 legacy_config->LCR_request = hidl_config.mustRequestLcr;
1929 legacy_config->burst_duration = hidl_config.burstDuration;
1930 legacy_config->preamble =
1931 convertHidlRttPreambleToLegacy(hidl_config.preamble);
1932 legacy_config->bw = convertHidlRttBwToLegacy(hidl_config.bw);
1933 return true;
1934 }
1936 bool convertHidlVectorOfRttConfigToLegacy(
1937 const std::vector<RttConfig>& hidl_configs,
1938 std::vector<legacy_hal::wifi_rtt_config>* legacy_configs) {
1939 if (!legacy_configs) {
1940 return false;
1941 }
1942 *legacy_configs = {};
1943 for (const auto& hidl_config : hidl_configs) {
1944 legacy_hal::wifi_rtt_config legacy_config;
1945 if (!convertHidlRttConfigToLegacy(hidl_config, &legacy_config)) {
1946 return false;
1947 }
1948 legacy_configs->push_back(legacy_config);
1949 }
1950 return true;
1951 }
1953 bool convertHidlRttLciInformationToLegacy(
1954 const RttLciInformation& hidl_info,
1955 legacy_hal::wifi_lci_information* legacy_info) {
1956 if (!legacy_info) {
1957 return false;
1958 }
1959 *legacy_info = {};
1960 legacy_info->latitude = hidl_info.latitude;
1961 legacy_info->longitude = hidl_info.longitude;
1962 legacy_info->altitude = hidl_info.altitude;
1963 legacy_info->latitude_unc = hidl_info.latitudeUnc;
1964 legacy_info->longitude_unc = hidl_info.longitudeUnc;
1965 legacy_info->altitude_unc = hidl_info.altitudeUnc;
1966 legacy_info->motion_pattern =
1967 convertHidlRttMotionPatternToLegacy(hidl_info.motionPattern);
1968 legacy_info->floor = hidl_info.floor;
1969 legacy_info->height_above_floor = hidl_info.heightAboveFloor;
1970 legacy_info->height_unc = hidl_info.heightUnc;
1971 return true;
1972 }
1974 bool convertHidlRttLcrInformationToLegacy(
1975 const RttLcrInformation& hidl_info,
1976 legacy_hal::wifi_lcr_information* legacy_info) {
1977 if (!legacy_info) {
1978 return false;
1979 }
1980 *legacy_info = {};
1981 CHECK(hidl_info.countryCode.size() == sizeof(legacy_info->country_code));
1982 memcpy(legacy_info->country_code,
1983 hidl_info.countryCode.data(),
1984 hidl_info.countryCode.size());
1985 if (hidl_info.civicInfo.size() > sizeof(legacy_info->civic_info)) {
1986 return false;
1987 }
1988 legacy_info->length = hidl_info.civicInfo.size();
1989 memcpy(legacy_info->civic_info,
1990 hidl_info.civicInfo.c_str(),
1991 hidl_info.civicInfo.size());
1992 return true;
1993 }
1995 bool convertHidlRttResponderToLegacy(
1996 const RttResponder& hidl_responder,
1997 legacy_hal::wifi_rtt_responder* legacy_responder) {
1998 if (!legacy_responder) {
1999 return false;
2000 }
2001 *legacy_responder = {};
2002 if (!convertHidlWifiChannelInfoToLegacy(hidl_responder.channel,
2003 &legacy_responder->channel)) {
2004 return false;
2005 }
2006 legacy_responder->preamble =
2007 convertHidlRttPreambleToLegacy(hidl_responder.preamble);
2008 return true;
2009 }
2011 bool convertLegacyRttResponderToHidl(
2012 const legacy_hal::wifi_rtt_responder& legacy_responder,
2013 RttResponder* hidl_responder) {
2014 if (!hidl_responder) {
2015 return false;
2016 }
2017 *hidl_responder = {};
2018 if (!convertLegacyWifiChannelInfoToHidl(legacy_responder.channel,
2019 &hidl_responder->channel)) {
2020 return false;
2021 }
2022 hidl_responder->preamble =
2023 convertLegacyRttPreambleToHidl(legacy_responder.preamble);
2024 return true;
2025 }
2027 bool convertLegacyRttCapabilitiesToHidl(
2028 const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
2029 RttCapabilities* hidl_capabilities) {
2030 if (!hidl_capabilities) {
2031 return false;
2032 }
2033 *hidl_capabilities = {};
2034 hidl_capabilities->rttOneSidedSupported =
2035 legacy_capabilities.rtt_one_sided_supported;
2036 hidl_capabilities->rttFtmSupported = legacy_capabilities.rtt_ftm_supported;
2037 hidl_capabilities->lciSupported = legacy_capabilities.lci_support;
2038 hidl_capabilities->lcrSupported = legacy_capabilities.lcr_support;
2039 hidl_capabilities->responderSupported =
2040 legacy_capabilities.responder_supported;
2041 hidl_capabilities->preambleSupport = 0;
2042 for (const auto flag : {legacy_hal::WIFI_RTT_PREAMBLE_LEGACY,
2043 legacy_hal::WIFI_RTT_PREAMBLE_HT,
2044 legacy_hal::WIFI_RTT_PREAMBLE_VHT}) {
2045 if (legacy_capabilities.preamble_support & flag) {
2046 hidl_capabilities->preambleSupport |=
2047 static_cast<std::underlying_type<RttPreamble>::type>(
2048 convertLegacyRttPreambleToHidl(flag));
2049 }
2050 }
2051 hidl_capabilities->bwSupport = 0;
2052 for (const auto flag : {legacy_hal::WIFI_RTT_BW_5,
2053 legacy_hal::WIFI_RTT_BW_10,
2054 legacy_hal::WIFI_RTT_BW_20,
2055 legacy_hal::WIFI_RTT_BW_40,
2056 legacy_hal::WIFI_RTT_BW_80,
2057 legacy_hal::WIFI_RTT_BW_160}) {
2058 if (legacy_capabilities.bw_support & flag) {
2059 hidl_capabilities->bwSupport |=
2060 static_cast<std::underlying_type<RttBw>::type>(
2061 convertLegacyRttBwToHidl(flag));
2062 }
2063 }
2064 hidl_capabilities->mcVersion = legacy_capabilities.mc_version;
2065 return true;
2066 }
2068 bool convertLegacyWifiRateInfoToHidl(const legacy_hal::wifi_rate& legacy_rate,
2069 WifiRateInfo* hidl_rate) {
2070 if (!hidl_rate) {
2071 return false;
2072 }
2073 *hidl_rate = {};
2074 hidl_rate->preamble =
2075 convertLegacyWifiRatePreambleToHidl(legacy_rate.preamble);
2076 hidl_rate->nss = convertLegacyWifiRateNssToHidl(legacy_rate.nss);
2077 hidl_rate->bw = convertLegacyWifiChannelWidthToHidl(
2078 static_cast<legacy_hal::wifi_channel_width>(legacy_rate.bw));
2079 hidl_rate->rateMcsIdx = legacy_rate.rateMcsIdx;
2080 hidl_rate->bitRateInKbps = legacy_rate.bitrate;
2081 return true;
2082 }
2084 bool convertLegacyRttResultToHidl(
2085 const legacy_hal::wifi_rtt_result& legacy_result, RttResult* hidl_result) {
2086 if (!hidl_result) {
2087 return false;
2088 }
2089 *hidl_result = {};
2090 CHECK(sizeof(legacy_result.addr) == hidl_result->addr.size());
2091 memcpy(
2092 hidl_result->addr.data(), legacy_result.addr, sizeof(legacy_result.addr));
2093 hidl_result->burstNum = legacy_result.burst_num;
2094 hidl_result->measurementNumber = legacy_result.measurement_number;
2095 hidl_result->successNumber = legacy_result.success_number;
2096 hidl_result->numberPerBurstPeer = legacy_result.number_per_burst_peer;
2097 hidl_result->status = convertLegacyRttStatusToHidl(legacy_result.status);
2098 hidl_result->retryAfterDuration = legacy_result.retry_after_duration;
2099 hidl_result->type = convertLegacyRttTypeToHidl(legacy_result.type);
2100 hidl_result->rssi = legacy_result.rssi;
2101 hidl_result->rssiSpread = legacy_result.rssi_spread;
2102 if (!convertLegacyWifiRateInfoToHidl(legacy_result.tx_rate,
2103 &hidl_result->txRate)) {
2104 return false;
2105 }
2106 if (!convertLegacyWifiRateInfoToHidl(legacy_result.rx_rate,
2107 &hidl_result->rxRate)) {
2108 return false;
2109 }
2110 hidl_result->rtt = legacy_result.rtt;
2111 hidl_result->rttSd = legacy_result.rtt_sd;
2112 hidl_result->rttSpread = legacy_result.rtt_spread;
2113 hidl_result->distanceInMm = legacy_result.distance_mm;
2114 hidl_result->distanceSdInMm = legacy_result.distance_sd_mm;
2115 hidl_result->distanceSpreadInMm = legacy_result.distance_spread_mm;
2116 hidl_result->timeStampInUs = legacy_result.ts;
2117 hidl_result->burstDurationInMs = legacy_result.burst_duration;
2118 hidl_result->negotiatedBurstNum = legacy_result.negotiated_burst_num;
2119 if (legacy_result.LCI && !convertLegacyIeToHidl(*legacy_result.LCI,
2120 &hidl_result->lci)) {
2121 return false;
2122 }
2123 if (legacy_result.LCR && !convertLegacyIeToHidl(*legacy_result.LCR,
2124 &hidl_result->lcr)) {
2125 return false;
2126 }
2127 return true;
2128 }
2130 bool convertLegacyVectorOfRttResultToHidl(
2131 const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
2132 std::vector<RttResult>* hidl_results) {
2133 if (!hidl_results) {
2134 return false;
2135 }
2136 *hidl_results = {};
2137 for (const auto legacy_result : legacy_results) {
2138 RttResult hidl_result;
2139 if (!convertLegacyRttResultToHidl(*legacy_result, &hidl_result)) {
2140 return false;
2141 }
2142 hidl_results->push_back(hidl_result);
2143 }
2144 return true;
2145 }
2146 } // namespace hidl_struct_util
2147 } // namespace implementation
2148 } // namespace V1_0
2149 } // namespace wifi
2150 } // namespace hardware
2151 } // namespace android