1 /*
2  * Copyright (C) 2016 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <android-base/logging.h>
18 #include <utils/SystemClock.h>
19 
20 #include "hidl_struct_util.h"
21 
22 namespace android {
23 namespace hardware {
24 namespace wifi {
25 namespace V1_5 {
26 namespace implementation {
27 namespace hidl_struct_util {
28 
29 WifiChannelWidthInMhz convertLegacyWifiChannelWidthToHidl(
30     legacy_hal::wifi_channel_width type);
31 
safeConvertChar(const char * str,size_t max_len)32 hidl_string safeConvertChar(const char* str, size_t max_len) {
33     const char* c = str;
34     size_t size = 0;
35     while (*c && (unsigned char)*c < 128 && size < max_len) {
36         ++size;
37         ++c;
38     }
39     return hidl_string(str, size);
40 }
41 
convertLegacyLoggerFeatureToHidlChipCapability(uint32_t feature)42 IWifiChip::ChipCapabilityMask convertLegacyLoggerFeatureToHidlChipCapability(
43     uint32_t feature) {
44     using HidlChipCaps = IWifiChip::ChipCapabilityMask;
45     switch (feature) {
46         case legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED:
47             return HidlChipCaps::DEBUG_MEMORY_FIRMWARE_DUMP;
48         case legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED:
49             return HidlChipCaps::DEBUG_MEMORY_DRIVER_DUMP;
50         case legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED:
51             return HidlChipCaps::DEBUG_RING_BUFFER_CONNECT_EVENT;
52         case legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED:
53             return HidlChipCaps::DEBUG_RING_BUFFER_POWER_EVENT;
54         case legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED:
55             return HidlChipCaps::DEBUG_RING_BUFFER_WAKELOCK_EVENT;
56     };
57     CHECK(false) << "Unknown legacy feature: " << feature;
58     return {};
59 }
60 
61 IWifiStaIface::StaIfaceCapabilityMask
convertLegacyLoggerFeatureToHidlStaIfaceCapability(uint32_t feature)62 convertLegacyLoggerFeatureToHidlStaIfaceCapability(uint32_t feature) {
63     using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
64     switch (feature) {
65         case legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED:
66             return HidlStaIfaceCaps::DEBUG_PACKET_FATE;
67     };
68     CHECK(false) << "Unknown legacy feature: " << feature;
69     return {};
70 }
71 
convertLegacyFeatureToHidlChipCapability(uint64_t feature)72 V1_5::IWifiChip::ChipCapabilityMask convertLegacyFeatureToHidlChipCapability(
73     uint64_t feature) {
74     using HidlChipCaps = V1_5::IWifiChip::ChipCapabilityMask;
75     switch (feature) {
76         case WIFI_FEATURE_SET_TX_POWER_LIMIT:
77             return HidlChipCaps::SET_TX_POWER_LIMIT;
78         case WIFI_FEATURE_USE_BODY_HEAD_SAR:
79             return HidlChipCaps::USE_BODY_HEAD_SAR;
80         case WIFI_FEATURE_D2D_RTT:
81             return HidlChipCaps::D2D_RTT;
82         case WIFI_FEATURE_D2AP_RTT:
83             return HidlChipCaps::D2AP_RTT;
84         case WIFI_FEATURE_INFRA_60G:
85             return HidlChipCaps::WIGIG;
86         case WIFI_FEATURE_SET_LATENCY_MODE:
87             return HidlChipCaps::SET_LATENCY_MODE;
88         case WIFI_FEATURE_P2P_RAND_MAC:
89             return HidlChipCaps::P2P_RAND_MAC;
90     };
91     CHECK(false) << "Unknown legacy feature: " << feature;
92     return {};
93 }
94 
95 IWifiStaIface::StaIfaceCapabilityMask
convertLegacyFeatureToHidlStaIfaceCapability(uint64_t feature)96 convertLegacyFeatureToHidlStaIfaceCapability(uint64_t feature) {
97     using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
98     switch (feature) {
99         case WIFI_FEATURE_GSCAN:
100             return HidlStaIfaceCaps::BACKGROUND_SCAN;
101         case WIFI_FEATURE_LINK_LAYER_STATS:
102             return HidlStaIfaceCaps::LINK_LAYER_STATS;
103         case WIFI_FEATURE_RSSI_MONITOR:
104             return HidlStaIfaceCaps::RSSI_MONITOR;
105         case WIFI_FEATURE_CONTROL_ROAMING:
106             return HidlStaIfaceCaps::CONTROL_ROAMING;
107         case WIFI_FEATURE_IE_WHITELIST:
108             return HidlStaIfaceCaps::PROBE_IE_WHITELIST;
109         case WIFI_FEATURE_SCAN_RAND:
110             return HidlStaIfaceCaps::SCAN_RAND;
111         case WIFI_FEATURE_INFRA_5G:
112             return HidlStaIfaceCaps::STA_5G;
113         case WIFI_FEATURE_HOTSPOT:
114             return HidlStaIfaceCaps::HOTSPOT;
115         case WIFI_FEATURE_PNO:
116             return HidlStaIfaceCaps::PNO;
117         case WIFI_FEATURE_TDLS:
118             return HidlStaIfaceCaps::TDLS;
119         case WIFI_FEATURE_TDLS_OFFCHANNEL:
120             return HidlStaIfaceCaps::TDLS_OFFCHANNEL;
121         case WIFI_FEATURE_CONFIG_NDO:
122             return HidlStaIfaceCaps::ND_OFFLOAD;
123         case WIFI_FEATURE_MKEEP_ALIVE:
124             return HidlStaIfaceCaps::KEEP_ALIVE;
125     };
126     CHECK(false) << "Unknown legacy feature: " << feature;
127     return {};
128 }
129 
convertLegacyFeaturesToHidlChipCapabilities(uint64_t legacy_feature_set,uint32_t legacy_logger_feature_set,uint32_t * hidl_caps)130 bool convertLegacyFeaturesToHidlChipCapabilities(
131     uint64_t legacy_feature_set, uint32_t legacy_logger_feature_set,
132     uint32_t* hidl_caps) {
133     if (!hidl_caps) {
134         return false;
135     }
136     *hidl_caps = {};
137     using HidlChipCaps = IWifiChip::ChipCapabilityMask;
138     for (const auto feature : {legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED,
139                                legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED,
140                                legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED,
141                                legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED,
142                                legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED}) {
143         if (feature & legacy_logger_feature_set) {
144             *hidl_caps |=
145                 convertLegacyLoggerFeatureToHidlChipCapability(feature);
146         }
147     }
148     std::vector<uint64_t> features = {WIFI_FEATURE_SET_TX_POWER_LIMIT,
149                                       WIFI_FEATURE_USE_BODY_HEAD_SAR,
150                                       WIFI_FEATURE_D2D_RTT,
151                                       WIFI_FEATURE_D2AP_RTT,
152                                       WIFI_FEATURE_INFRA_60G,
153                                       WIFI_FEATURE_SET_LATENCY_MODE,
154                                       WIFI_FEATURE_P2P_RAND_MAC};
155     for (const auto feature : features) {
156         if (feature & legacy_feature_set) {
157             *hidl_caps |= convertLegacyFeatureToHidlChipCapability(feature);
158         }
159     }
160 
161     // There are no flags for these 3 in the legacy feature set. Adding them to
162     // the set because all the current devices support it.
163     *hidl_caps |= HidlChipCaps::DEBUG_RING_BUFFER_VENDOR_DATA;
164     *hidl_caps |= HidlChipCaps::DEBUG_HOST_WAKE_REASON_STATS;
165     *hidl_caps |= HidlChipCaps::DEBUG_ERROR_ALERTS;
166     return true;
167 }
168 
convertLegacyDebugRingBufferFlagsToHidl(uint32_t flag)169 WifiDebugRingBufferFlags convertLegacyDebugRingBufferFlagsToHidl(
170     uint32_t flag) {
171     switch (flag) {
172         case WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES:
173             return WifiDebugRingBufferFlags::HAS_BINARY_ENTRIES;
174         case WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES:
175             return WifiDebugRingBufferFlags::HAS_ASCII_ENTRIES;
176     };
177     CHECK(false) << "Unknown legacy flag: " << flag;
178     return {};
179 }
180 
convertLegacyDebugRingBufferStatusToHidl(const legacy_hal::wifi_ring_buffer_status & legacy_status,WifiDebugRingBufferStatus * hidl_status)181 bool convertLegacyDebugRingBufferStatusToHidl(
182     const legacy_hal::wifi_ring_buffer_status& legacy_status,
183     WifiDebugRingBufferStatus* hidl_status) {
184     if (!hidl_status) {
185         return false;
186     }
187     *hidl_status = {};
188     hidl_status->ringName =
189         safeConvertChar(reinterpret_cast<const char*>(legacy_status.name),
190                         sizeof(legacy_status.name));
191     hidl_status->flags = 0;
192     for (const auto flag : {WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES,
193                             WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES}) {
194         if (flag & legacy_status.flags) {
195             hidl_status->flags |= static_cast<
196                 std::underlying_type<WifiDebugRingBufferFlags>::type>(
197                 convertLegacyDebugRingBufferFlagsToHidl(flag));
198         }
199     }
200     hidl_status->ringId = legacy_status.ring_id;
201     hidl_status->sizeInBytes = legacy_status.ring_buffer_byte_size;
202     // Calculate free size of the ring the buffer. We don't need to send the
203     // exact read/write pointers that were there in the legacy HAL interface.
204     if (legacy_status.written_bytes >= legacy_status.read_bytes) {
205         hidl_status->freeSizeInBytes =
206             legacy_status.ring_buffer_byte_size -
207             (legacy_status.written_bytes - legacy_status.read_bytes);
208     } else {
209         hidl_status->freeSizeInBytes =
210             legacy_status.read_bytes - legacy_status.written_bytes;
211     }
212     hidl_status->verboseLevel = legacy_status.verbose_level;
213     return true;
214 }
215 
convertLegacyVectorOfDebugRingBufferStatusToHidl(const std::vector<legacy_hal::wifi_ring_buffer_status> & legacy_status_vec,std::vector<WifiDebugRingBufferStatus> * hidl_status_vec)216 bool convertLegacyVectorOfDebugRingBufferStatusToHidl(
217     const std::vector<legacy_hal::wifi_ring_buffer_status>& legacy_status_vec,
218     std::vector<WifiDebugRingBufferStatus>* hidl_status_vec) {
219     if (!hidl_status_vec) {
220         return false;
221     }
222     *hidl_status_vec = {};
223     for (const auto& legacy_status : legacy_status_vec) {
224         WifiDebugRingBufferStatus hidl_status;
225         if (!convertLegacyDebugRingBufferStatusToHidl(legacy_status,
226                                                       &hidl_status)) {
227             return false;
228         }
229         hidl_status_vec->push_back(hidl_status);
230     }
231     return true;
232 }
233 
convertLegacyWakeReasonStatsToHidl(const legacy_hal::WakeReasonStats & legacy_stats,WifiDebugHostWakeReasonStats * hidl_stats)234 bool convertLegacyWakeReasonStatsToHidl(
235     const legacy_hal::WakeReasonStats& legacy_stats,
236     WifiDebugHostWakeReasonStats* hidl_stats) {
237     if (!hidl_stats) {
238         return false;
239     }
240     *hidl_stats = {};
241     hidl_stats->totalCmdEventWakeCnt =
242         legacy_stats.wake_reason_cnt.total_cmd_event_wake;
243     hidl_stats->cmdEventWakeCntPerType = legacy_stats.cmd_event_wake_cnt;
244     hidl_stats->totalDriverFwLocalWakeCnt =
245         legacy_stats.wake_reason_cnt.total_driver_fw_local_wake;
246     hidl_stats->driverFwLocalWakeCntPerType =
247         legacy_stats.driver_fw_local_wake_cnt;
248     hidl_stats->totalRxPacketWakeCnt =
249         legacy_stats.wake_reason_cnt.total_rx_data_wake;
250     hidl_stats->rxPktWakeDetails.rxUnicastCnt =
251         legacy_stats.wake_reason_cnt.rx_wake_details.rx_unicast_cnt;
252     hidl_stats->rxPktWakeDetails.rxMulticastCnt =
253         legacy_stats.wake_reason_cnt.rx_wake_details.rx_multicast_cnt;
254     hidl_stats->rxPktWakeDetails.rxBroadcastCnt =
255         legacy_stats.wake_reason_cnt.rx_wake_details.rx_broadcast_cnt;
256     hidl_stats->rxMulticastPkWakeDetails.ipv4RxMulticastAddrCnt =
257         legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
258             .ipv4_rx_multicast_addr_cnt;
259     hidl_stats->rxMulticastPkWakeDetails.ipv6RxMulticastAddrCnt =
260         legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
261             .ipv6_rx_multicast_addr_cnt;
262     hidl_stats->rxMulticastPkWakeDetails.otherRxMulticastAddrCnt =
263         legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
264             .other_rx_multicast_addr_cnt;
265     hidl_stats->rxIcmpPkWakeDetails.icmpPkt =
266         legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp_pkt;
267     hidl_stats->rxIcmpPkWakeDetails.icmp6Pkt =
268         legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_pkt;
269     hidl_stats->rxIcmpPkWakeDetails.icmp6Ra =
270         legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ra;
271     hidl_stats->rxIcmpPkWakeDetails.icmp6Na =
272         legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_na;
273     hidl_stats->rxIcmpPkWakeDetails.icmp6Ns =
274         legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ns;
275     return true;
276 }
277 
convertHidlTxPowerScenarioToLegacy(V1_1::IWifiChip::TxPowerScenario hidl_scenario)278 legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy(
279     V1_1::IWifiChip::TxPowerScenario hidl_scenario) {
280     switch (hidl_scenario) {
281         // This is the only supported scenario for V1_1
282         case V1_1::IWifiChip::TxPowerScenario::VOICE_CALL:
283             return legacy_hal::WIFI_POWER_SCENARIO_VOICE_CALL;
284     };
285     CHECK(false);
286 }
287 
convertHidlTxPowerScenarioToLegacy_1_2(V1_2::IWifiChip::TxPowerScenario hidl_scenario)288 legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy_1_2(
289     V1_2::IWifiChip::TxPowerScenario hidl_scenario) {
290     switch (hidl_scenario) {
291         // This is the only supported scenario for V1_1
292         case V1_2::IWifiChip::TxPowerScenario::VOICE_CALL:
293             return legacy_hal::WIFI_POWER_SCENARIO_VOICE_CALL;
294         // Those are the supported scenarios for V1_2
295         case V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF:
296             return legacy_hal::WIFI_POWER_SCENARIO_ON_HEAD_CELL_OFF;
297         case V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_ON:
298             return legacy_hal::WIFI_POWER_SCENARIO_ON_HEAD_CELL_ON;
299         case V1_2::IWifiChip::TxPowerScenario::ON_BODY_CELL_OFF:
300             return legacy_hal::WIFI_POWER_SCENARIO_ON_BODY_CELL_OFF;
301         case V1_2::IWifiChip::TxPowerScenario::ON_BODY_CELL_ON:
302             return legacy_hal::WIFI_POWER_SCENARIO_ON_BODY_CELL_ON;
303     };
304     CHECK(false);
305 }
306 
convertHidlLatencyModeToLegacy(V1_3::IWifiChip::LatencyMode hidl_latency_mode)307 legacy_hal::wifi_latency_mode convertHidlLatencyModeToLegacy(
308     V1_3::IWifiChip::LatencyMode hidl_latency_mode) {
309     switch (hidl_latency_mode) {
310         case V1_3::IWifiChip::LatencyMode::NORMAL:
311             return legacy_hal::WIFI_LATENCY_MODE_NORMAL;
312         case V1_3::IWifiChip::LatencyMode::LOW:
313             return legacy_hal::WIFI_LATENCY_MODE_LOW;
314     }
315     CHECK(false);
316 }
317 
convertLegacyWifiMacInfoToHidl(const legacy_hal::WifiMacInfo & legacy_mac_info,V1_4::IWifiChipEventCallback::RadioModeInfo * hidl_radio_mode_info)318 bool convertLegacyWifiMacInfoToHidl(
319     const legacy_hal::WifiMacInfo& legacy_mac_info,
320     V1_4::IWifiChipEventCallback::RadioModeInfo* hidl_radio_mode_info) {
321     if (!hidl_radio_mode_info) {
322         return false;
323     }
324     *hidl_radio_mode_info = {};
325 
326     hidl_radio_mode_info->radioId = legacy_mac_info.wlan_mac_id;
327     // Convert from bitmask of bands in the legacy HAL to enum value in
328     // the HIDL interface.
329     if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND &&
330         legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND &&
331         legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND) {
332         hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_24GHZ_5GHZ_6GHZ;
333     } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND &&
334                legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
335         hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_5GHZ_6GHZ;
336     } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND) {
337         hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_6GHZ;
338     } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND &&
339                legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
340         hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_24GHZ_5GHZ;
341     } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND) {
342         hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_24GHZ;
343     } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
344         hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_5GHZ;
345     } else {
346         hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_UNSPECIFIED;
347     }
348     std::vector<V1_2::IWifiChipEventCallback::IfaceInfo> iface_info_vec;
349     for (const auto& legacy_iface_info : legacy_mac_info.iface_infos) {
350         V1_2::IWifiChipEventCallback::IfaceInfo iface_info;
351         iface_info.name = legacy_iface_info.name;
352         iface_info.channel = legacy_iface_info.channel;
353         iface_info_vec.push_back(iface_info);
354     }
355     hidl_radio_mode_info->ifaceInfos = iface_info_vec;
356     return true;
357 }
358 
convertHidlWifiBandToLegacyMacBand(V1_5::WifiBand hidl_band)359 uint32_t convertHidlWifiBandToLegacyMacBand(V1_5::WifiBand hidl_band) {
360     switch (hidl_band) {
361         case V1_5::WifiBand::BAND_24GHZ:
362             return legacy_hal::WLAN_MAC_2_4_BAND;
363         case V1_5::WifiBand::BAND_5GHZ:
364         case V1_5::WifiBand::BAND_5GHZ_DFS:
365         case V1_5::WifiBand::BAND_5GHZ_WITH_DFS:
366             return legacy_hal::WLAN_MAC_5_0_BAND;
367         case V1_5::WifiBand::BAND_24GHZ_5GHZ:
368         case V1_5::WifiBand::BAND_24GHZ_5GHZ_WITH_DFS:
369             return (legacy_hal::WLAN_MAC_2_4_BAND |
370                     legacy_hal::WLAN_MAC_5_0_BAND);
371         case V1_5::WifiBand::BAND_6GHZ:
372             return legacy_hal::WLAN_MAC_6_0_BAND;
373         case V1_5::WifiBand::BAND_5GHZ_6GHZ:
374             return (legacy_hal::WLAN_MAC_5_0_BAND |
375                     legacy_hal::WLAN_MAC_6_0_BAND);
376         case V1_5::WifiBand::BAND_24GHZ_5GHZ_6GHZ:
377         case V1_5::WifiBand::BAND_24GHZ_5GHZ_WITH_DFS_6GHZ:
378             return (legacy_hal::WLAN_MAC_2_4_BAND |
379                     legacy_hal::WLAN_MAC_5_0_BAND |
380                     legacy_hal::WLAN_MAC_6_0_BAND);
381         case V1_5::WifiBand::BAND_60GHZ:
382             return legacy_hal::WLAN_MAC_60_0_BAND;
383         default:
384             return (
385                 legacy_hal::WLAN_MAC_2_4_BAND | legacy_hal::WLAN_MAC_5_0_BAND |
386                 legacy_hal::WLAN_MAC_6_0_BAND | legacy_hal::WLAN_MAC_60_0_BAND);
387     }
388 }
389 
convertHidlWifiIfaceModeToLegacy(uint32_t hidl_iface_mask)390 uint32_t convertHidlWifiIfaceModeToLegacy(uint32_t hidl_iface_mask) {
391     uint32_t legacy_iface_mask = 0;
392     if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_STA) {
393         legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_STA);
394     }
395     if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_SOFTAP) {
396         legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_SOFTAP);
397     }
398     if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_P2P_CLIENT) {
399         legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_P2P_CLIENT);
400     }
401     if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_P2P_GO) {
402         legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_P2P_GO);
403     }
404     if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_NAN) {
405         legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_NAN);
406     }
407     if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_TDLS) {
408         legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_TDLS);
409     }
410     if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_MESH) {
411         legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_MESH);
412     }
413     if (hidl_iface_mask & V1_5::WifiIfaceMode::IFACE_MODE_IBSS) {
414         legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_IBSS);
415     }
416     return legacy_iface_mask;
417 }
418 
convertLegacyWifiInterfaceModeToHidl(uint32_t legacy_iface_mask)419 uint32_t convertLegacyWifiInterfaceModeToHidl(uint32_t legacy_iface_mask) {
420     uint32_t hidl_iface_mask = 0;
421     if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_STA)) {
422         hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_STA;
423     }
424     if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_SOFTAP)) {
425         hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_SOFTAP;
426     }
427     if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_P2P_CLIENT)) {
428         hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_P2P_CLIENT;
429     }
430     if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_P2P_GO)) {
431         hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_P2P_GO;
432     }
433     if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_NAN)) {
434         hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_NAN;
435     }
436     if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_TDLS)) {
437         hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_TDLS;
438     }
439     if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_MESH)) {
440         hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_MESH;
441     }
442     if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_IBSS)) {
443         hidl_iface_mask |= V1_5::WifiIfaceMode::IFACE_MODE_IBSS;
444     }
445     return hidl_iface_mask;
446 }
447 
convertHidlUsableChannelFilterToLegacy(uint32_t hidl_filter_mask)448 uint32_t convertHidlUsableChannelFilterToLegacy(uint32_t hidl_filter_mask) {
449     uint32_t legacy_filter_mask = 0;
450     if (hidl_filter_mask &
451         IWifiChip::UsableChannelFilter::CELLULAR_COEXISTENCE) {
452         legacy_filter_mask |=
453             legacy_hal::WIFI_USABLE_CHANNEL_FILTER_CELLULAR_COEXISTENCE;
454     }
455     if (hidl_filter_mask & IWifiChip::UsableChannelFilter::CONCURRENCY) {
456         legacy_filter_mask |=
457             legacy_hal::WIFI_USABLE_CHANNEL_FILTER_CONCURRENCY;
458     }
459     return legacy_filter_mask;
460 }
461 
convertLegacyWifiUsableChannelToHidl(const legacy_hal::wifi_usable_channel & legacy_usable_channel,V1_5::WifiUsableChannel * hidl_usable_channel)462 bool convertLegacyWifiUsableChannelToHidl(
463     const legacy_hal::wifi_usable_channel& legacy_usable_channel,
464     V1_5::WifiUsableChannel* hidl_usable_channel) {
465     if (!hidl_usable_channel) {
466         return false;
467     }
468     *hidl_usable_channel = {};
469     hidl_usable_channel->channel = legacy_usable_channel.freq;
470     hidl_usable_channel->channelBandwidth =
471         convertLegacyWifiChannelWidthToHidl(legacy_usable_channel.width);
472     hidl_usable_channel->ifaceModeMask = convertLegacyWifiInterfaceModeToHidl(
473         legacy_usable_channel.iface_mode_mask);
474 
475     return true;
476 }
477 
convertLegacyWifiUsableChannelsToHidl(const std::vector<legacy_hal::wifi_usable_channel> & legacy_usable_channels,std::vector<V1_5::WifiUsableChannel> * hidl_usable_channels)478 bool convertLegacyWifiUsableChannelsToHidl(
479     const std::vector<legacy_hal::wifi_usable_channel>& legacy_usable_channels,
480     std::vector<V1_5::WifiUsableChannel>* hidl_usable_channels) {
481     if (!hidl_usable_channels) {
482         return false;
483     }
484     *hidl_usable_channels = {};
485     for (const auto& legacy_usable_channel : legacy_usable_channels) {
486         V1_5::WifiUsableChannel hidl_usable_channel;
487         if (!convertLegacyWifiUsableChannelToHidl(legacy_usable_channel,
488                                                   &hidl_usable_channel)) {
489             return false;
490         }
491         hidl_usable_channels->push_back(hidl_usable_channel);
492     }
493     return true;
494 }
495 
convertLegacyWifiMacInfosToHidl(const std::vector<legacy_hal::WifiMacInfo> & legacy_mac_infos,std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo> * hidl_radio_mode_infos)496 bool convertLegacyWifiMacInfosToHidl(
497     const std::vector<legacy_hal::WifiMacInfo>& legacy_mac_infos,
498     std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo>*
499         hidl_radio_mode_infos) {
500     if (!hidl_radio_mode_infos) {
501         return false;
502     }
503     *hidl_radio_mode_infos = {};
504 
505     for (const auto& legacy_mac_info : legacy_mac_infos) {
506         V1_4::IWifiChipEventCallback::RadioModeInfo hidl_radio_mode_info;
507         if (!convertLegacyWifiMacInfoToHidl(legacy_mac_info,
508                                             &hidl_radio_mode_info)) {
509             return false;
510         }
511         hidl_radio_mode_infos->push_back(hidl_radio_mode_info);
512     }
513     return true;
514 }
515 
convertLegacyFeaturesToHidlStaCapabilities(uint64_t legacy_feature_set,uint32_t legacy_logger_feature_set,uint32_t * hidl_caps)516 bool convertLegacyFeaturesToHidlStaCapabilities(
517     uint64_t legacy_feature_set, uint32_t legacy_logger_feature_set,
518     uint32_t* hidl_caps) {
519     if (!hidl_caps) {
520         return false;
521     }
522     *hidl_caps = {};
523     using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
524     for (const auto feature : {legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED}) {
525         if (feature & legacy_logger_feature_set) {
526             *hidl_caps |=
527                 convertLegacyLoggerFeatureToHidlStaIfaceCapability(feature);
528         }
529     }
530     for (const auto feature :
531          {WIFI_FEATURE_GSCAN, WIFI_FEATURE_LINK_LAYER_STATS,
532           WIFI_FEATURE_RSSI_MONITOR, WIFI_FEATURE_CONTROL_ROAMING,
533           WIFI_FEATURE_IE_WHITELIST, WIFI_FEATURE_SCAN_RAND,
534           WIFI_FEATURE_INFRA_5G, WIFI_FEATURE_HOTSPOT, WIFI_FEATURE_PNO,
535           WIFI_FEATURE_TDLS, WIFI_FEATURE_TDLS_OFFCHANNEL,
536           WIFI_FEATURE_CONFIG_NDO, WIFI_FEATURE_MKEEP_ALIVE}) {
537         if (feature & legacy_feature_set) {
538             *hidl_caps |= convertLegacyFeatureToHidlStaIfaceCapability(feature);
539         }
540     }
541     // There is no flag for this one in the legacy feature set. Adding it to the
542     // set because all the current devices support it.
543     *hidl_caps |= HidlStaIfaceCaps::APF;
544     return true;
545 }
546 
convertLegacyApfCapabilitiesToHidl(const legacy_hal::PacketFilterCapabilities & legacy_caps,StaApfPacketFilterCapabilities * hidl_caps)547 bool convertLegacyApfCapabilitiesToHidl(
548     const legacy_hal::PacketFilterCapabilities& legacy_caps,
549     StaApfPacketFilterCapabilities* hidl_caps) {
550     if (!hidl_caps) {
551         return false;
552     }
553     *hidl_caps = {};
554     hidl_caps->version = legacy_caps.version;
555     hidl_caps->maxLength = legacy_caps.max_len;
556     return true;
557 }
558 
convertHidlGscanReportEventFlagToLegacy(StaBackgroundScanBucketEventReportSchemeMask hidl_flag)559 uint8_t convertHidlGscanReportEventFlagToLegacy(
560     StaBackgroundScanBucketEventReportSchemeMask hidl_flag) {
561     using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
562     switch (hidl_flag) {
563         case HidlFlag::EACH_SCAN:
564             return REPORT_EVENTS_EACH_SCAN;
565         case HidlFlag::FULL_RESULTS:
566             return REPORT_EVENTS_FULL_RESULTS;
567         case HidlFlag::NO_BATCH:
568             return REPORT_EVENTS_NO_BATCH;
569     };
570     CHECK(false);
571 }
572 
convertLegacyGscanDataFlagToHidl(uint8_t legacy_flag)573 StaScanDataFlagMask convertLegacyGscanDataFlagToHidl(uint8_t legacy_flag) {
574     switch (legacy_flag) {
575         case legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED:
576             return StaScanDataFlagMask::INTERRUPTED;
577     };
578     CHECK(false) << "Unknown legacy flag: " << legacy_flag;
579     // To silence the compiler warning about reaching the end of non-void
580     // function.
581     return {};
582 }
583 
convertLegacyGscanCapabilitiesToHidl(const legacy_hal::wifi_gscan_capabilities & legacy_caps,StaBackgroundScanCapabilities * hidl_caps)584 bool convertLegacyGscanCapabilitiesToHidl(
585     const legacy_hal::wifi_gscan_capabilities& legacy_caps,
586     StaBackgroundScanCapabilities* hidl_caps) {
587     if (!hidl_caps) {
588         return false;
589     }
590     *hidl_caps = {};
591     hidl_caps->maxCacheSize = legacy_caps.max_scan_cache_size;
592     hidl_caps->maxBuckets = legacy_caps.max_scan_buckets;
593     hidl_caps->maxApCachePerScan = legacy_caps.max_ap_cache_per_scan;
594     hidl_caps->maxReportingThreshold = legacy_caps.max_scan_reporting_threshold;
595     return true;
596 }
597 
convertHidlWifiBandToLegacy(V1_0::WifiBand band)598 legacy_hal::wifi_band convertHidlWifiBandToLegacy(V1_0::WifiBand band) {
599     switch (band) {
600         case V1_0::WifiBand::BAND_UNSPECIFIED:
601             return legacy_hal::WIFI_BAND_UNSPECIFIED;
602         case V1_0::WifiBand::BAND_24GHZ:
603             return legacy_hal::WIFI_BAND_BG;
604         case V1_0::WifiBand::BAND_5GHZ:
605             return legacy_hal::WIFI_BAND_A;
606         case V1_0::WifiBand::BAND_5GHZ_DFS:
607             return legacy_hal::WIFI_BAND_A_DFS;
608         case V1_0::WifiBand::BAND_5GHZ_WITH_DFS:
609             return legacy_hal::WIFI_BAND_A_WITH_DFS;
610         case V1_0::WifiBand::BAND_24GHZ_5GHZ:
611             return legacy_hal::WIFI_BAND_ABG;
612         case V1_0::WifiBand::BAND_24GHZ_5GHZ_WITH_DFS:
613             return legacy_hal::WIFI_BAND_ABG_WITH_DFS;
614     };
615     CHECK(false);
616 }
617 
convertHidlGscanParamsToLegacy(const StaBackgroundScanParameters & hidl_scan_params,legacy_hal::wifi_scan_cmd_params * legacy_scan_params)618 bool convertHidlGscanParamsToLegacy(
619     const StaBackgroundScanParameters& hidl_scan_params,
620     legacy_hal::wifi_scan_cmd_params* legacy_scan_params) {
621     if (!legacy_scan_params) {
622         return false;
623     }
624     *legacy_scan_params = {};
625     legacy_scan_params->base_period = hidl_scan_params.basePeriodInMs;
626     legacy_scan_params->max_ap_per_scan = hidl_scan_params.maxApPerScan;
627     legacy_scan_params->report_threshold_percent =
628         hidl_scan_params.reportThresholdPercent;
629     legacy_scan_params->report_threshold_num_scans =
630         hidl_scan_params.reportThresholdNumScans;
631     if (hidl_scan_params.buckets.size() > MAX_BUCKETS) {
632         return false;
633     }
634     legacy_scan_params->num_buckets = hidl_scan_params.buckets.size();
635     for (uint32_t bucket_idx = 0; bucket_idx < hidl_scan_params.buckets.size();
636          bucket_idx++) {
637         const StaBackgroundScanBucketParameters& hidl_bucket_spec =
638             hidl_scan_params.buckets[bucket_idx];
639         legacy_hal::wifi_scan_bucket_spec& legacy_bucket_spec =
640             legacy_scan_params->buckets[bucket_idx];
641         if (hidl_bucket_spec.bucketIdx >= MAX_BUCKETS) {
642             return false;
643         }
644         legacy_bucket_spec.bucket = hidl_bucket_spec.bucketIdx;
645         legacy_bucket_spec.band =
646             convertHidlWifiBandToLegacy(hidl_bucket_spec.band);
647         legacy_bucket_spec.period = hidl_bucket_spec.periodInMs;
648         legacy_bucket_spec.max_period =
649             hidl_bucket_spec.exponentialMaxPeriodInMs;
650         legacy_bucket_spec.base = hidl_bucket_spec.exponentialBase;
651         legacy_bucket_spec.step_count = hidl_bucket_spec.exponentialStepCount;
652         legacy_bucket_spec.report_events = 0;
653         using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
654         for (const auto flag : {HidlFlag::EACH_SCAN, HidlFlag::FULL_RESULTS,
655                                 HidlFlag::NO_BATCH}) {
656             if (hidl_bucket_spec.eventReportScheme &
657                 static_cast<std::underlying_type<HidlFlag>::type>(flag)) {
658                 legacy_bucket_spec.report_events |=
659                     convertHidlGscanReportEventFlagToLegacy(flag);
660             }
661         }
662         if (hidl_bucket_spec.frequencies.size() > MAX_CHANNELS) {
663             return false;
664         }
665         legacy_bucket_spec.num_channels = hidl_bucket_spec.frequencies.size();
666         for (uint32_t freq_idx = 0;
667              freq_idx < hidl_bucket_spec.frequencies.size(); freq_idx++) {
668             legacy_bucket_spec.channels[freq_idx].channel =
669                 hidl_bucket_spec.frequencies[freq_idx];
670         }
671     }
672     return true;
673 }
674 
convertLegacyIeToHidl(const legacy_hal::wifi_information_element & legacy_ie,WifiInformationElement * hidl_ie)675 bool convertLegacyIeToHidl(
676     const legacy_hal::wifi_information_element& legacy_ie,
677     WifiInformationElement* hidl_ie) {
678     if (!hidl_ie) {
679         return false;
680     }
681     *hidl_ie = {};
682     hidl_ie->id = legacy_ie.id;
683     hidl_ie->data =
684         std::vector<uint8_t>(legacy_ie.data, legacy_ie.data + legacy_ie.len);
685     return true;
686 }
687 
convertLegacyIeBlobToHidl(const uint8_t * ie_blob,uint32_t ie_blob_len,std::vector<WifiInformationElement> * hidl_ies)688 bool convertLegacyIeBlobToHidl(const uint8_t* ie_blob, uint32_t ie_blob_len,
689                                std::vector<WifiInformationElement>* hidl_ies) {
690     if (!ie_blob || !hidl_ies) {
691         return false;
692     }
693     *hidl_ies = {};
694     const uint8_t* ies_begin = ie_blob;
695     const uint8_t* ies_end = ie_blob + ie_blob_len;
696     const uint8_t* next_ie = ies_begin;
697     using wifi_ie = legacy_hal::wifi_information_element;
698     constexpr size_t kIeHeaderLen = sizeof(wifi_ie);
699     // Each IE should atleast have the header (i.e |id| & |len| fields).
700     while (next_ie + kIeHeaderLen <= ies_end) {
701         const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie));
702         uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len;
703         if (next_ie + curr_ie_len > ies_end) {
704             LOG(ERROR) << "Error parsing IE blob. Next IE: " << (void*)next_ie
705                        << ", Curr IE len: " << curr_ie_len
706                        << ", IEs End: " << (void*)ies_end;
707             break;
708         }
709         WifiInformationElement hidl_ie;
710         if (!convertLegacyIeToHidl(legacy_ie, &hidl_ie)) {
711             LOG(ERROR) << "Error converting IE. Id: " << legacy_ie.id
712                        << ", len: " << legacy_ie.len;
713             break;
714         }
715         hidl_ies->push_back(std::move(hidl_ie));
716         next_ie += curr_ie_len;
717     }
718     // Check if the blob has been fully consumed.
719     if (next_ie != ies_end) {
720         LOG(ERROR) << "Failed to fully parse IE blob. Next IE: "
721                    << (void*)next_ie << ", IEs End: " << (void*)ies_end;
722     }
723     return true;
724 }
725 
convertLegacyGscanResultToHidl(const legacy_hal::wifi_scan_result & legacy_scan_result,bool has_ie_data,StaScanResult * hidl_scan_result)726 bool convertLegacyGscanResultToHidl(
727     const legacy_hal::wifi_scan_result& legacy_scan_result, bool has_ie_data,
728     StaScanResult* hidl_scan_result) {
729     if (!hidl_scan_result) {
730         return false;
731     }
732     *hidl_scan_result = {};
733     hidl_scan_result->timeStampInUs = legacy_scan_result.ts;
734     hidl_scan_result->ssid = std::vector<uint8_t>(
735         legacy_scan_result.ssid,
736         legacy_scan_result.ssid + strnlen(legacy_scan_result.ssid,
737                                           sizeof(legacy_scan_result.ssid) - 1));
738     memcpy(hidl_scan_result->bssid.data(), legacy_scan_result.bssid,
739            hidl_scan_result->bssid.size());
740     hidl_scan_result->frequency = legacy_scan_result.channel;
741     hidl_scan_result->rssi = legacy_scan_result.rssi;
742     hidl_scan_result->beaconPeriodInMs = legacy_scan_result.beacon_period;
743     hidl_scan_result->capability = legacy_scan_result.capability;
744     if (has_ie_data) {
745         std::vector<WifiInformationElement> ies;
746         if (!convertLegacyIeBlobToHidl(
747                 reinterpret_cast<const uint8_t*>(legacy_scan_result.ie_data),
748                 legacy_scan_result.ie_length, &ies)) {
749             return false;
750         }
751         hidl_scan_result->informationElements = std::move(ies);
752     }
753     return true;
754 }
755 
convertLegacyCachedGscanResultsToHidl(const legacy_hal::wifi_cached_scan_results & legacy_cached_scan_result,StaScanData * hidl_scan_data)756 bool convertLegacyCachedGscanResultsToHidl(
757     const legacy_hal::wifi_cached_scan_results& legacy_cached_scan_result,
758     StaScanData* hidl_scan_data) {
759     if (!hidl_scan_data) {
760         return false;
761     }
762     *hidl_scan_data = {};
763     hidl_scan_data->flags = 0;
764     for (const auto flag : {legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED}) {
765         if (legacy_cached_scan_result.flags & flag) {
766             hidl_scan_data->flags |=
767                 static_cast<std::underlying_type<StaScanDataFlagMask>::type>(
768                     convertLegacyGscanDataFlagToHidl(flag));
769         }
770     }
771     hidl_scan_data->bucketsScanned = legacy_cached_scan_result.buckets_scanned;
772 
773     CHECK(legacy_cached_scan_result.num_results >= 0 &&
774           legacy_cached_scan_result.num_results <= MAX_AP_CACHE_PER_SCAN);
775     std::vector<StaScanResult> hidl_scan_results;
776     for (int32_t result_idx = 0;
777          result_idx < legacy_cached_scan_result.num_results; result_idx++) {
778         StaScanResult hidl_scan_result;
779         if (!convertLegacyGscanResultToHidl(
780                 legacy_cached_scan_result.results[result_idx], false,
781                 &hidl_scan_result)) {
782             return false;
783         }
784         hidl_scan_results.push_back(hidl_scan_result);
785     }
786     hidl_scan_data->results = std::move(hidl_scan_results);
787     return true;
788 }
789 
convertLegacyVectorOfCachedGscanResultsToHidl(const std::vector<legacy_hal::wifi_cached_scan_results> & legacy_cached_scan_results,std::vector<StaScanData> * hidl_scan_datas)790 bool convertLegacyVectorOfCachedGscanResultsToHidl(
791     const std::vector<legacy_hal::wifi_cached_scan_results>&
792         legacy_cached_scan_results,
793     std::vector<StaScanData>* hidl_scan_datas) {
794     if (!hidl_scan_datas) {
795         return false;
796     }
797     *hidl_scan_datas = {};
798     for (const auto& legacy_cached_scan_result : legacy_cached_scan_results) {
799         StaScanData hidl_scan_data;
800         if (!convertLegacyCachedGscanResultsToHidl(legacy_cached_scan_result,
801                                                    &hidl_scan_data)) {
802             return false;
803         }
804         hidl_scan_datas->push_back(hidl_scan_data);
805     }
806     return true;
807 }
808 
convertLegacyDebugTxPacketFateToHidl(legacy_hal::wifi_tx_packet_fate fate)809 WifiDebugTxPacketFate convertLegacyDebugTxPacketFateToHidl(
810     legacy_hal::wifi_tx_packet_fate fate) {
811     switch (fate) {
812         case legacy_hal::TX_PKT_FATE_ACKED:
813             return WifiDebugTxPacketFate::ACKED;
814         case legacy_hal::TX_PKT_FATE_SENT:
815             return WifiDebugTxPacketFate::SENT;
816         case legacy_hal::TX_PKT_FATE_FW_QUEUED:
817             return WifiDebugTxPacketFate::FW_QUEUED;
818         case legacy_hal::TX_PKT_FATE_FW_DROP_INVALID:
819             return WifiDebugTxPacketFate::FW_DROP_INVALID;
820         case legacy_hal::TX_PKT_FATE_FW_DROP_NOBUFS:
821             return WifiDebugTxPacketFate::FW_DROP_NOBUFS;
822         case legacy_hal::TX_PKT_FATE_FW_DROP_OTHER:
823             return WifiDebugTxPacketFate::FW_DROP_OTHER;
824         case legacy_hal::TX_PKT_FATE_DRV_QUEUED:
825             return WifiDebugTxPacketFate::DRV_QUEUED;
826         case legacy_hal::TX_PKT_FATE_DRV_DROP_INVALID:
827             return WifiDebugTxPacketFate::DRV_DROP_INVALID;
828         case legacy_hal::TX_PKT_FATE_DRV_DROP_NOBUFS:
829             return WifiDebugTxPacketFate::DRV_DROP_NOBUFS;
830         case legacy_hal::TX_PKT_FATE_DRV_DROP_OTHER:
831             return WifiDebugTxPacketFate::DRV_DROP_OTHER;
832     };
833     CHECK(false) << "Unknown legacy fate type: " << fate;
834 }
835 
convertLegacyDebugRxPacketFateToHidl(legacy_hal::wifi_rx_packet_fate fate)836 WifiDebugRxPacketFate convertLegacyDebugRxPacketFateToHidl(
837     legacy_hal::wifi_rx_packet_fate fate) {
838     switch (fate) {
839         case legacy_hal::RX_PKT_FATE_SUCCESS:
840             return WifiDebugRxPacketFate::SUCCESS;
841         case legacy_hal::RX_PKT_FATE_FW_QUEUED:
842             return WifiDebugRxPacketFate::FW_QUEUED;
843         case legacy_hal::RX_PKT_FATE_FW_DROP_FILTER:
844             return WifiDebugRxPacketFate::FW_DROP_FILTER;
845         case legacy_hal::RX_PKT_FATE_FW_DROP_INVALID:
846             return WifiDebugRxPacketFate::FW_DROP_INVALID;
847         case legacy_hal::RX_PKT_FATE_FW_DROP_NOBUFS:
848             return WifiDebugRxPacketFate::FW_DROP_NOBUFS;
849         case legacy_hal::RX_PKT_FATE_FW_DROP_OTHER:
850             return WifiDebugRxPacketFate::FW_DROP_OTHER;
851         case legacy_hal::RX_PKT_FATE_DRV_QUEUED:
852             return WifiDebugRxPacketFate::DRV_QUEUED;
853         case legacy_hal::RX_PKT_FATE_DRV_DROP_FILTER:
854             return WifiDebugRxPacketFate::DRV_DROP_FILTER;
855         case legacy_hal::RX_PKT_FATE_DRV_DROP_INVALID:
856             return WifiDebugRxPacketFate::DRV_DROP_INVALID;
857         case legacy_hal::RX_PKT_FATE_DRV_DROP_NOBUFS:
858             return WifiDebugRxPacketFate::DRV_DROP_NOBUFS;
859         case legacy_hal::RX_PKT_FATE_DRV_DROP_OTHER:
860             return WifiDebugRxPacketFate::DRV_DROP_OTHER;
861     };
862     CHECK(false) << "Unknown legacy fate type: " << fate;
863 }
864 
convertLegacyDebugPacketFateFrameTypeToHidl(legacy_hal::frame_type type)865 WifiDebugPacketFateFrameType convertLegacyDebugPacketFateFrameTypeToHidl(
866     legacy_hal::frame_type type) {
867     switch (type) {
868         case legacy_hal::FRAME_TYPE_UNKNOWN:
869             return WifiDebugPacketFateFrameType::UNKNOWN;
870         case legacy_hal::FRAME_TYPE_ETHERNET_II:
871             return WifiDebugPacketFateFrameType::ETHERNET_II;
872         case legacy_hal::FRAME_TYPE_80211_MGMT:
873             return WifiDebugPacketFateFrameType::MGMT_80211;
874     };
875     CHECK(false) << "Unknown legacy frame type: " << type;
876 }
877 
convertLegacyDebugPacketFateFrameToHidl(const legacy_hal::frame_info & legacy_frame,WifiDebugPacketFateFrameInfo * hidl_frame)878 bool convertLegacyDebugPacketFateFrameToHidl(
879     const legacy_hal::frame_info& legacy_frame,
880     WifiDebugPacketFateFrameInfo* hidl_frame) {
881     if (!hidl_frame) {
882         return false;
883     }
884     *hidl_frame = {};
885     hidl_frame->frameType =
886         convertLegacyDebugPacketFateFrameTypeToHidl(legacy_frame.payload_type);
887     hidl_frame->frameLen = legacy_frame.frame_len;
888     hidl_frame->driverTimestampUsec = legacy_frame.driver_timestamp_usec;
889     hidl_frame->firmwareTimestampUsec = legacy_frame.firmware_timestamp_usec;
890     const uint8_t* frame_begin = reinterpret_cast<const uint8_t*>(
891         legacy_frame.frame_content.ethernet_ii_bytes);
892     hidl_frame->frameContent =
893         std::vector<uint8_t>(frame_begin, frame_begin + legacy_frame.frame_len);
894     return true;
895 }
896 
convertLegacyDebugTxPacketFateToHidl(const legacy_hal::wifi_tx_report & legacy_fate,WifiDebugTxPacketFateReport * hidl_fate)897 bool convertLegacyDebugTxPacketFateToHidl(
898     const legacy_hal::wifi_tx_report& legacy_fate,
899     WifiDebugTxPacketFateReport* hidl_fate) {
900     if (!hidl_fate) {
901         return false;
902     }
903     *hidl_fate = {};
904     hidl_fate->fate = convertLegacyDebugTxPacketFateToHidl(legacy_fate.fate);
905     return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
906                                                    &hidl_fate->frameInfo);
907 }
908 
convertLegacyVectorOfDebugTxPacketFateToHidl(const std::vector<legacy_hal::wifi_tx_report> & legacy_fates,std::vector<WifiDebugTxPacketFateReport> * hidl_fates)909 bool convertLegacyVectorOfDebugTxPacketFateToHidl(
910     const std::vector<legacy_hal::wifi_tx_report>& legacy_fates,
911     std::vector<WifiDebugTxPacketFateReport>* hidl_fates) {
912     if (!hidl_fates) {
913         return false;
914     }
915     *hidl_fates = {};
916     for (const auto& legacy_fate : legacy_fates) {
917         WifiDebugTxPacketFateReport hidl_fate;
918         if (!convertLegacyDebugTxPacketFateToHidl(legacy_fate, &hidl_fate)) {
919             return false;
920         }
921         hidl_fates->push_back(hidl_fate);
922     }
923     return true;
924 }
925 
convertLegacyDebugRxPacketFateToHidl(const legacy_hal::wifi_rx_report & legacy_fate,WifiDebugRxPacketFateReport * hidl_fate)926 bool convertLegacyDebugRxPacketFateToHidl(
927     const legacy_hal::wifi_rx_report& legacy_fate,
928     WifiDebugRxPacketFateReport* hidl_fate) {
929     if (!hidl_fate) {
930         return false;
931     }
932     *hidl_fate = {};
933     hidl_fate->fate = convertLegacyDebugRxPacketFateToHidl(legacy_fate.fate);
934     return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
935                                                    &hidl_fate->frameInfo);
936 }
937 
convertLegacyVectorOfDebugRxPacketFateToHidl(const std::vector<legacy_hal::wifi_rx_report> & legacy_fates,std::vector<WifiDebugRxPacketFateReport> * hidl_fates)938 bool convertLegacyVectorOfDebugRxPacketFateToHidl(
939     const std::vector<legacy_hal::wifi_rx_report>& legacy_fates,
940     std::vector<WifiDebugRxPacketFateReport>* hidl_fates) {
941     if (!hidl_fates) {
942         return false;
943     }
944     *hidl_fates = {};
945     for (const auto& legacy_fate : legacy_fates) {
946         WifiDebugRxPacketFateReport hidl_fate;
947         if (!convertLegacyDebugRxPacketFateToHidl(legacy_fate, &hidl_fate)) {
948             return false;
949         }
950         hidl_fates->push_back(hidl_fate);
951     }
952     return true;
953 }
954 
convertLegacyLinkLayerRadioStatsToHidl(const legacy_hal::LinkLayerRadioStats & legacy_radio_stat,V1_5::StaLinkLayerRadioStats * hidl_radio_stat)955 bool convertLegacyLinkLayerRadioStatsToHidl(
956     const legacy_hal::LinkLayerRadioStats& legacy_radio_stat,
957     V1_5::StaLinkLayerRadioStats* hidl_radio_stat) {
958     if (!hidl_radio_stat) {
959         return false;
960     }
961     *hidl_radio_stat = {};
962 
963     hidl_radio_stat->radioId = legacy_radio_stat.stats.radio;
964     hidl_radio_stat->V1_3.V1_0.onTimeInMs = legacy_radio_stat.stats.on_time;
965     hidl_radio_stat->V1_3.V1_0.txTimeInMs = legacy_radio_stat.stats.tx_time;
966     hidl_radio_stat->V1_3.V1_0.rxTimeInMs = legacy_radio_stat.stats.rx_time;
967     hidl_radio_stat->V1_3.V1_0.onTimeInMsForScan =
968         legacy_radio_stat.stats.on_time_scan;
969     hidl_radio_stat->V1_3.V1_0.txTimeInMsPerLevel =
970         legacy_radio_stat.tx_time_per_levels;
971     hidl_radio_stat->V1_3.onTimeInMsForNanScan =
972         legacy_radio_stat.stats.on_time_nbd;
973     hidl_radio_stat->V1_3.onTimeInMsForBgScan =
974         legacy_radio_stat.stats.on_time_gscan;
975     hidl_radio_stat->V1_3.onTimeInMsForRoamScan =
976         legacy_radio_stat.stats.on_time_roam_scan;
977     hidl_radio_stat->V1_3.onTimeInMsForPnoScan =
978         legacy_radio_stat.stats.on_time_pno_scan;
979     hidl_radio_stat->V1_3.onTimeInMsForHs20Scan =
980         legacy_radio_stat.stats.on_time_hs20;
981 
982     std::vector<V1_3::WifiChannelStats> hidl_channel_stats;
983 
984     for (const auto& channel_stat : legacy_radio_stat.channel_stats) {
985         V1_3::WifiChannelStats hidl_channel_stat;
986         hidl_channel_stat.onTimeInMs = channel_stat.on_time;
987         hidl_channel_stat.ccaBusyTimeInMs = channel_stat.cca_busy_time;
988         /*
989          * TODO once b/119142899 is fixed,
990          * replace below code with convertLegacyWifiChannelInfoToHidl()
991          */
992         hidl_channel_stat.channel.width = WifiChannelWidthInMhz::WIDTH_20;
993         hidl_channel_stat.channel.centerFreq = channel_stat.channel.center_freq;
994         hidl_channel_stat.channel.centerFreq0 =
995             channel_stat.channel.center_freq0;
996         hidl_channel_stat.channel.centerFreq1 =
997             channel_stat.channel.center_freq1;
998         hidl_channel_stats.push_back(hidl_channel_stat);
999     }
1000 
1001     hidl_radio_stat->V1_3.channelStats = hidl_channel_stats;
1002 
1003     return true;
1004 }
1005 
convertLegacyLinkLayerStatsToHidl(const legacy_hal::LinkLayerStats & legacy_stats,StaLinkLayerStats * hidl_stats)1006 bool convertLegacyLinkLayerStatsToHidl(
1007     const legacy_hal::LinkLayerStats& legacy_stats,
1008     StaLinkLayerStats* hidl_stats) {
1009     if (!hidl_stats) {
1010         return false;
1011     }
1012     *hidl_stats = {};
1013     // iface legacy_stats conversion.
1014     hidl_stats->iface.V1_0.beaconRx = legacy_stats.iface.beacon_rx;
1015     hidl_stats->iface.V1_0.avgRssiMgmt = legacy_stats.iface.rssi_mgmt;
1016     hidl_stats->iface.V1_0.wmeBePktStats.rxMpdu =
1017         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu;
1018     hidl_stats->iface.V1_0.wmeBePktStats.txMpdu =
1019         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu;
1020     hidl_stats->iface.V1_0.wmeBePktStats.lostMpdu =
1021         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost;
1022     hidl_stats->iface.V1_0.wmeBePktStats.retries =
1023         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries;
1024     hidl_stats->iface.wmeBeContentionTimeStats.contentionTimeMinInUsec =
1025         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_min;
1026     hidl_stats->iface.wmeBeContentionTimeStats.contentionTimeMaxInUsec =
1027         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_max;
1028     hidl_stats->iface.wmeBeContentionTimeStats.contentionTimeAvgInUsec =
1029         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_avg;
1030     hidl_stats->iface.wmeBeContentionTimeStats.contentionNumSamples =
1031         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples;
1032     hidl_stats->iface.V1_0.wmeBkPktStats.rxMpdu =
1033         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu;
1034     hidl_stats->iface.V1_0.wmeBkPktStats.txMpdu =
1035         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu;
1036     hidl_stats->iface.V1_0.wmeBkPktStats.lostMpdu =
1037         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost;
1038     hidl_stats->iface.V1_0.wmeBkPktStats.retries =
1039         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries;
1040     hidl_stats->iface.wmeBkContentionTimeStats.contentionTimeMinInUsec =
1041         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_min;
1042     hidl_stats->iface.wmeBkContentionTimeStats.contentionTimeMaxInUsec =
1043         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_max;
1044     hidl_stats->iface.wmeBkContentionTimeStats.contentionTimeAvgInUsec =
1045         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_avg;
1046     hidl_stats->iface.wmeBkContentionTimeStats.contentionNumSamples =
1047         legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples;
1048     hidl_stats->iface.V1_0.wmeViPktStats.rxMpdu =
1049         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu;
1050     hidl_stats->iface.V1_0.wmeViPktStats.txMpdu =
1051         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu;
1052     hidl_stats->iface.V1_0.wmeViPktStats.lostMpdu =
1053         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost;
1054     hidl_stats->iface.V1_0.wmeViPktStats.retries =
1055         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries;
1056     hidl_stats->iface.wmeViContentionTimeStats.contentionTimeMinInUsec =
1057         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_min;
1058     hidl_stats->iface.wmeViContentionTimeStats.contentionTimeMaxInUsec =
1059         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_max;
1060     hidl_stats->iface.wmeViContentionTimeStats.contentionTimeAvgInUsec =
1061         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_avg;
1062     hidl_stats->iface.wmeViContentionTimeStats.contentionNumSamples =
1063         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples;
1064     hidl_stats->iface.V1_0.wmeVoPktStats.rxMpdu =
1065         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu;
1066     hidl_stats->iface.V1_0.wmeVoPktStats.txMpdu =
1067         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu;
1068     hidl_stats->iface.V1_0.wmeVoPktStats.lostMpdu =
1069         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost;
1070     hidl_stats->iface.V1_0.wmeVoPktStats.retries =
1071         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries;
1072     hidl_stats->iface.wmeVoContentionTimeStats.contentionTimeMinInUsec =
1073         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_min;
1074     hidl_stats->iface.wmeVoContentionTimeStats.contentionTimeMaxInUsec =
1075         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_max;
1076     hidl_stats->iface.wmeVoContentionTimeStats.contentionTimeAvgInUsec =
1077         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_avg;
1078     hidl_stats->iface.wmeVoContentionTimeStats.contentionNumSamples =
1079         legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples;
1080     hidl_stats->iface.timeSliceDutyCycleInPercent =
1081         legacy_stats.iface.info.time_slicing_duty_cycle_percent;
1082     // peer info legacy_stats conversion.
1083     std::vector<StaPeerInfo> hidl_peers_info_stats;
1084     for (const auto& legacy_peer_info_stats : legacy_stats.peers) {
1085         StaPeerInfo hidl_peer_info_stats;
1086         if (!convertLegacyPeerInfoStatsToHidl(legacy_peer_info_stats,
1087                                               &hidl_peer_info_stats)) {
1088             return false;
1089         }
1090         hidl_peers_info_stats.push_back(hidl_peer_info_stats);
1091     }
1092     hidl_stats->iface.peers = hidl_peers_info_stats;
1093     // radio legacy_stats conversion.
1094     std::vector<V1_5::StaLinkLayerRadioStats> hidl_radios_stats;
1095     for (const auto& legacy_radio_stats : legacy_stats.radios) {
1096         V1_5::StaLinkLayerRadioStats hidl_radio_stats;
1097         if (!convertLegacyLinkLayerRadioStatsToHidl(legacy_radio_stats,
1098                                                     &hidl_radio_stats)) {
1099             return false;
1100         }
1101         hidl_radios_stats.push_back(hidl_radio_stats);
1102     }
1103     hidl_stats->radios = hidl_radios_stats;
1104     // Timestamp in the HAL wrapper here since it's not provided in the legacy
1105     // HAL API.
1106     hidl_stats->timeStampInMs = uptimeMillis();
1107     return true;
1108 }
1109 
convertLegacyPeerInfoStatsToHidl(const legacy_hal::WifiPeerInfo & legacy_peer_info_stats,StaPeerInfo * hidl_peer_info_stats)1110 bool convertLegacyPeerInfoStatsToHidl(
1111     const legacy_hal::WifiPeerInfo& legacy_peer_info_stats,
1112     StaPeerInfo* hidl_peer_info_stats) {
1113     if (!hidl_peer_info_stats) {
1114         return false;
1115     }
1116     *hidl_peer_info_stats = {};
1117     hidl_peer_info_stats->staCount =
1118         legacy_peer_info_stats.peer_info.bssload.sta_count;
1119     hidl_peer_info_stats->chanUtil =
1120         legacy_peer_info_stats.peer_info.bssload.chan_util;
1121 
1122     std::vector<StaRateStat> hidlRateStats;
1123     for (const auto& legacy_rate_stats : legacy_peer_info_stats.rate_stats) {
1124         StaRateStat rateStat;
1125         if (!convertLegacyWifiRateInfoToHidl(legacy_rate_stats.rate,
1126                                              &rateStat.rateInfo)) {
1127             return false;
1128         }
1129         rateStat.txMpdu = legacy_rate_stats.tx_mpdu;
1130         rateStat.rxMpdu = legacy_rate_stats.rx_mpdu;
1131         rateStat.mpduLost = legacy_rate_stats.mpdu_lost;
1132         rateStat.retries = legacy_rate_stats.retries;
1133         hidlRateStats.push_back(rateStat);
1134     }
1135     hidl_peer_info_stats->rateStats = hidlRateStats;
1136     return true;
1137 }
1138 
convertLegacyRoamingCapabilitiesToHidl(const legacy_hal::wifi_roaming_capabilities & legacy_caps,StaRoamingCapabilities * hidl_caps)1139 bool convertLegacyRoamingCapabilitiesToHidl(
1140     const legacy_hal::wifi_roaming_capabilities& legacy_caps,
1141     StaRoamingCapabilities* hidl_caps) {
1142     if (!hidl_caps) {
1143         return false;
1144     }
1145     *hidl_caps = {};
1146     hidl_caps->maxBlacklistSize = legacy_caps.max_blacklist_size;
1147     hidl_caps->maxWhitelistSize = legacy_caps.max_whitelist_size;
1148     return true;
1149 }
1150 
convertHidlRoamingConfigToLegacy(const StaRoamingConfig & hidl_config,legacy_hal::wifi_roaming_config * legacy_config)1151 bool convertHidlRoamingConfigToLegacy(
1152     const StaRoamingConfig& hidl_config,
1153     legacy_hal::wifi_roaming_config* legacy_config) {
1154     if (!legacy_config) {
1155         return false;
1156     }
1157     *legacy_config = {};
1158     if (hidl_config.bssidBlacklist.size() > MAX_BLACKLIST_BSSID ||
1159         hidl_config.ssidWhitelist.size() > MAX_WHITELIST_SSID) {
1160         return false;
1161     }
1162     legacy_config->num_blacklist_bssid = hidl_config.bssidBlacklist.size();
1163     uint32_t i = 0;
1164     for (const auto& bssid : hidl_config.bssidBlacklist) {
1165         CHECK(bssid.size() == sizeof(legacy_hal::mac_addr));
1166         memcpy(legacy_config->blacklist_bssid[i++], bssid.data(), bssid.size());
1167     }
1168     legacy_config->num_whitelist_ssid = hidl_config.ssidWhitelist.size();
1169     i = 0;
1170     for (const auto& ssid : hidl_config.ssidWhitelist) {
1171         CHECK(ssid.size() <= sizeof(legacy_hal::ssid_t::ssid_str));
1172         legacy_config->whitelist_ssid[i].length = ssid.size();
1173         memcpy(legacy_config->whitelist_ssid[i].ssid_str, ssid.data(),
1174                ssid.size());
1175         i++;
1176     }
1177     return true;
1178 }
1179 
convertHidlRoamingStateToLegacy(StaRoamingState state)1180 legacy_hal::fw_roaming_state_t convertHidlRoamingStateToLegacy(
1181     StaRoamingState state) {
1182     switch (state) {
1183         case StaRoamingState::ENABLED:
1184             return legacy_hal::ROAMING_ENABLE;
1185         case StaRoamingState::DISABLED:
1186             return legacy_hal::ROAMING_DISABLE;
1187     };
1188     CHECK(false);
1189 }
1190 
convertHidlNanMatchAlgToLegacy(NanMatchAlg type)1191 legacy_hal::NanMatchAlg convertHidlNanMatchAlgToLegacy(NanMatchAlg type) {
1192     switch (type) {
1193         case NanMatchAlg::MATCH_ONCE:
1194             return legacy_hal::NAN_MATCH_ALG_MATCH_ONCE;
1195         case NanMatchAlg::MATCH_CONTINUOUS:
1196             return legacy_hal::NAN_MATCH_ALG_MATCH_CONTINUOUS;
1197         case NanMatchAlg::MATCH_NEVER:
1198             return legacy_hal::NAN_MATCH_ALG_MATCH_NEVER;
1199     }
1200     CHECK(false);
1201 }
1202 
convertHidlNanPublishTypeToLegacy(NanPublishType type)1203 legacy_hal::NanPublishType convertHidlNanPublishTypeToLegacy(
1204     NanPublishType type) {
1205     switch (type) {
1206         case NanPublishType::UNSOLICITED:
1207             return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED;
1208         case NanPublishType::SOLICITED:
1209             return legacy_hal::NAN_PUBLISH_TYPE_SOLICITED;
1210         case NanPublishType::UNSOLICITED_SOLICITED:
1211             return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
1212     }
1213     CHECK(false);
1214 }
1215 
convertHidlNanTxTypeToLegacy(NanTxType type)1216 legacy_hal::NanTxType convertHidlNanTxTypeToLegacy(NanTxType type) {
1217     switch (type) {
1218         case NanTxType::BROADCAST:
1219             return legacy_hal::NAN_TX_TYPE_BROADCAST;
1220         case NanTxType::UNICAST:
1221             return legacy_hal::NAN_TX_TYPE_UNICAST;
1222     }
1223     CHECK(false);
1224 }
1225 
convertHidlNanSubscribeTypeToLegacy(NanSubscribeType type)1226 legacy_hal::NanSubscribeType convertHidlNanSubscribeTypeToLegacy(
1227     NanSubscribeType type) {
1228     switch (type) {
1229         case NanSubscribeType::PASSIVE:
1230             return legacy_hal::NAN_SUBSCRIBE_TYPE_PASSIVE;
1231         case NanSubscribeType::ACTIVE:
1232             return legacy_hal::NAN_SUBSCRIBE_TYPE_ACTIVE;
1233     }
1234     CHECK(false);
1235 }
1236 
convertHidlNanSrfTypeToLegacy(NanSrfType type)1237 legacy_hal::NanSRFType convertHidlNanSrfTypeToLegacy(NanSrfType type) {
1238     switch (type) {
1239         case NanSrfType::BLOOM_FILTER:
1240             return legacy_hal::NAN_SRF_ATTR_BLOOM_FILTER;
1241         case NanSrfType::PARTIAL_MAC_ADDR:
1242             return legacy_hal::NAN_SRF_ATTR_PARTIAL_MAC_ADDR;
1243     }
1244     CHECK(false);
1245 }
1246 
convertHidlNanDataPathChannelCfgToLegacy(NanDataPathChannelCfg type)1247 legacy_hal::NanDataPathChannelCfg convertHidlNanDataPathChannelCfgToLegacy(
1248     NanDataPathChannelCfg type) {
1249     switch (type) {
1250         case NanDataPathChannelCfg::CHANNEL_NOT_REQUESTED:
1251             return legacy_hal::NAN_DP_CHANNEL_NOT_REQUESTED;
1252         case NanDataPathChannelCfg::REQUEST_CHANNEL_SETUP:
1253             return legacy_hal::NAN_DP_REQUEST_CHANNEL_SETUP;
1254         case NanDataPathChannelCfg::FORCE_CHANNEL_SETUP:
1255             return legacy_hal::NAN_DP_FORCE_CHANNEL_SETUP;
1256     }
1257     CHECK(false);
1258 }
1259 
convertLegacyNanStatusTypeToHidl(legacy_hal::NanStatusType type)1260 NanStatusType convertLegacyNanStatusTypeToHidl(legacy_hal::NanStatusType type) {
1261     switch (type) {
1262         case legacy_hal::NAN_STATUS_SUCCESS:
1263             return NanStatusType::SUCCESS;
1264         case legacy_hal::NAN_STATUS_INTERNAL_FAILURE:
1265             return NanStatusType::INTERNAL_FAILURE;
1266         case legacy_hal::NAN_STATUS_PROTOCOL_FAILURE:
1267             return NanStatusType::PROTOCOL_FAILURE;
1268         case legacy_hal::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID:
1269             return NanStatusType::INVALID_SESSION_ID;
1270         case legacy_hal::NAN_STATUS_NO_RESOURCE_AVAILABLE:
1271             return NanStatusType::NO_RESOURCES_AVAILABLE;
1272         case legacy_hal::NAN_STATUS_INVALID_PARAM:
1273             return NanStatusType::INVALID_ARGS;
1274         case legacy_hal::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID:
1275             return NanStatusType::INVALID_PEER_ID;
1276         case legacy_hal::NAN_STATUS_INVALID_NDP_ID:
1277             return NanStatusType::INVALID_NDP_ID;
1278         case legacy_hal::NAN_STATUS_NAN_NOT_ALLOWED:
1279             return NanStatusType::NAN_NOT_ALLOWED;
1280         case legacy_hal::NAN_STATUS_NO_OTA_ACK:
1281             return NanStatusType::NO_OTA_ACK;
1282         case legacy_hal::NAN_STATUS_ALREADY_ENABLED:
1283             return NanStatusType::ALREADY_ENABLED;
1284         case legacy_hal::NAN_STATUS_FOLLOWUP_QUEUE_FULL:
1285             return NanStatusType::FOLLOWUP_TX_QUEUE_FULL;
1286         case legacy_hal::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED:
1287             return NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED;
1288     }
1289     CHECK(false);
1290 }
1291 
convertToWifiNanStatus(legacy_hal::NanStatusType type,const char * str,size_t max_len,WifiNanStatus * wifiNanStatus)1292 void convertToWifiNanStatus(legacy_hal::NanStatusType type, const char* str,
1293                             size_t max_len, WifiNanStatus* wifiNanStatus) {
1294     wifiNanStatus->status = convertLegacyNanStatusTypeToHidl(type);
1295     wifiNanStatus->description = safeConvertChar(str, max_len);
1296 }
1297 
convertHidlNanEnableRequestToLegacy(const V1_4::NanEnableRequest & hidl_request,legacy_hal::NanEnableRequest * legacy_request)1298 bool convertHidlNanEnableRequestToLegacy(
1299     const V1_4::NanEnableRequest& hidl_request,
1300     legacy_hal::NanEnableRequest* legacy_request) {
1301     if (!legacy_request) {
1302         LOG(ERROR)
1303             << "convertHidlNanEnableRequestToLegacy: null legacy_request";
1304         return false;
1305     }
1306     *legacy_request = {};
1307 
1308     legacy_request->config_2dot4g_support = 1;
1309     legacy_request->support_2dot4g_val =
1310         hidl_request.operateInBand[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1311     legacy_request->config_support_5g = 1;
1312     legacy_request->support_5g_val =
1313         hidl_request.operateInBand[(size_t)NanBandIndex::NAN_BAND_5GHZ];
1314     legacy_request->config_hop_count_limit = 1;
1315     legacy_request->hop_count_limit_val = hidl_request.hopCountMax;
1316     legacy_request->master_pref = hidl_request.configParams.masterPref;
1317     legacy_request->discovery_indication_cfg = 0;
1318     legacy_request->discovery_indication_cfg |=
1319         hidl_request.configParams.disableDiscoveryAddressChangeIndication ? 0x1
1320                                                                           : 0x0;
1321     legacy_request->discovery_indication_cfg |=
1322         hidl_request.configParams.disableStartedClusterIndication ? 0x2 : 0x0;
1323     legacy_request->discovery_indication_cfg |=
1324         hidl_request.configParams.disableJoinedClusterIndication ? 0x4 : 0x0;
1325     legacy_request->config_sid_beacon = 1;
1326     if (hidl_request.configParams.numberOfPublishServiceIdsInBeacon > 127) {
1327         LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
1328                       "numberOfPublishServiceIdsInBeacon > 127";
1329         return false;
1330     }
1331     legacy_request->sid_beacon_val =
1332         (hidl_request.configParams.includePublishServiceIdsInBeacon ? 0x1
1333                                                                     : 0x0) |
1334         (hidl_request.configParams.numberOfPublishServiceIdsInBeacon << 1);
1335     legacy_request->config_subscribe_sid_beacon = 1;
1336     if (hidl_request.configParams.numberOfSubscribeServiceIdsInBeacon > 127) {
1337         LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
1338                       "numberOfSubscribeServiceIdsInBeacon > 127";
1339         return false;
1340     }
1341     legacy_request->subscribe_sid_beacon_val =
1342         (hidl_request.configParams.includeSubscribeServiceIdsInBeacon ? 0x1
1343                                                                       : 0x0) |
1344         (hidl_request.configParams.numberOfSubscribeServiceIdsInBeacon << 1);
1345     legacy_request->config_rssi_window_size = 1;
1346     legacy_request->rssi_window_size_val =
1347         hidl_request.configParams.rssiWindowSize;
1348     legacy_request->config_disc_mac_addr_randomization = 1;
1349     legacy_request->disc_mac_addr_rand_interval_sec =
1350         hidl_request.configParams.macAddressRandomizationIntervalSec;
1351     legacy_request->config_2dot4g_rssi_close = 1;
1352     if (hidl_request.configParams.bandSpecificConfig.size() != 3) {
1353         LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
1354                       "bandSpecificConfig.size() != 3";
1355         return false;
1356     }
1357     legacy_request->rssi_close_2dot4g_val =
1358         hidl_request.configParams
1359             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1360             .rssiClose;
1361     legacy_request->config_2dot4g_rssi_middle = 1;
1362     legacy_request->rssi_middle_2dot4g_val =
1363         hidl_request.configParams
1364             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1365             .rssiMiddle;
1366     legacy_request->config_2dot4g_rssi_proximity = 1;
1367     legacy_request->rssi_proximity_2dot4g_val =
1368         hidl_request.configParams
1369             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1370             .rssiCloseProximity;
1371     legacy_request->config_scan_params = 1;
1372     legacy_request->scan_params_val
1373         .dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
1374         hidl_request.configParams
1375             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1376             .dwellTimeMs;
1377     legacy_request->scan_params_val
1378         .scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
1379         hidl_request.configParams
1380             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1381             .scanPeriodSec;
1382     legacy_request->config_dw.config_2dot4g_dw_band =
1383         hidl_request.configParams
1384             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1385             .validDiscoveryWindowIntervalVal;
1386     legacy_request->config_dw.dw_2dot4g_interval_val =
1387         hidl_request.configParams
1388             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1389             .discoveryWindowIntervalVal;
1390     legacy_request->config_5g_rssi_close = 1;
1391     legacy_request->rssi_close_5g_val =
1392         hidl_request.configParams
1393             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1394             .rssiClose;
1395     legacy_request->config_5g_rssi_middle = 1;
1396     legacy_request->rssi_middle_5g_val =
1397         hidl_request.configParams
1398             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1399             .rssiMiddle;
1400     legacy_request->config_5g_rssi_close_proximity = 1;
1401     legacy_request->rssi_close_proximity_5g_val =
1402         hidl_request.configParams
1403             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1404             .rssiCloseProximity;
1405     legacy_request->scan_params_val
1406         .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1407         hidl_request.configParams
1408             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1409             .dwellTimeMs;
1410     legacy_request->scan_params_val
1411         .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1412         hidl_request.configParams
1413             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1414             .scanPeriodSec;
1415     legacy_request->scan_params_val
1416         .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1417         hidl_request.configParams
1418             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1419             .dwellTimeMs;
1420     legacy_request->scan_params_val
1421         .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1422         hidl_request.configParams
1423             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1424             .scanPeriodSec;
1425     legacy_request->config_dw.config_5g_dw_band =
1426         hidl_request.configParams
1427             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1428             .validDiscoveryWindowIntervalVal;
1429     legacy_request->config_dw.dw_5g_interval_val =
1430         hidl_request.configParams
1431             .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1432             .discoveryWindowIntervalVal;
1433     if (hidl_request.debugConfigs.validClusterIdVals) {
1434         legacy_request->cluster_low =
1435             hidl_request.debugConfigs.clusterIdBottomRangeVal;
1436         legacy_request->cluster_high =
1437             hidl_request.debugConfigs.clusterIdTopRangeVal;
1438     } else {  // need 'else' since not configurable in legacy HAL
1439         legacy_request->cluster_low = 0x0000;
1440         legacy_request->cluster_high = 0xFFFF;
1441     }
1442     legacy_request->config_intf_addr =
1443         hidl_request.debugConfigs.validIntfAddrVal;
1444     memcpy(legacy_request->intf_addr_val,
1445            hidl_request.debugConfigs.intfAddrVal.data(), 6);
1446     legacy_request->config_oui = hidl_request.debugConfigs.validOuiVal;
1447     legacy_request->oui_val = hidl_request.debugConfigs.ouiVal;
1448     legacy_request->config_random_factor_force =
1449         hidl_request.debugConfigs.validRandomFactorForceVal;
1450     legacy_request->random_factor_force_val =
1451         hidl_request.debugConfigs.randomFactorForceVal;
1452     legacy_request->config_hop_count_force =
1453         hidl_request.debugConfigs.validHopCountForceVal;
1454     legacy_request->hop_count_force_val =
1455         hidl_request.debugConfigs.hopCountForceVal;
1456     legacy_request->config_24g_channel =
1457         hidl_request.debugConfigs.validDiscoveryChannelVal;
1458     legacy_request->channel_24g_val =
1459         hidl_request.debugConfigs
1460             .discoveryChannelMhzVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1461     legacy_request->config_5g_channel =
1462         hidl_request.debugConfigs.validDiscoveryChannelVal;
1463     legacy_request->channel_5g_val =
1464         hidl_request.debugConfigs
1465             .discoveryChannelMhzVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
1466     legacy_request->config_2dot4g_beacons =
1467         hidl_request.debugConfigs.validUseBeaconsInBandVal;
1468     legacy_request->beacon_2dot4g_val =
1469         hidl_request.debugConfigs
1470             .useBeaconsInBandVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1471     legacy_request->config_5g_beacons =
1472         hidl_request.debugConfigs.validUseBeaconsInBandVal;
1473     legacy_request->beacon_5g_val =
1474         hidl_request.debugConfigs
1475             .useBeaconsInBandVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
1476     legacy_request->config_2dot4g_sdf =
1477         hidl_request.debugConfigs.validUseSdfInBandVal;
1478     legacy_request->sdf_2dot4g_val =
1479         hidl_request.debugConfigs
1480             .useSdfInBandVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1481     legacy_request->config_5g_sdf =
1482         hidl_request.debugConfigs.validUseSdfInBandVal;
1483     legacy_request->sdf_5g_val =
1484         hidl_request.debugConfigs
1485             .useSdfInBandVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
1486 
1487     /* TODO: b/145609058
1488      * Missing updates needed to legacy_hal::NanEnableRequest and conversion to
1489      * it for 6GHz band */
1490 
1491     return true;
1492 }
1493 
convertHidlNanEnableRequest_1_4ToLegacy(const V1_4::NanEnableRequest & hidl_request1,const NanConfigRequestSupplemental & hidl_request2,legacy_hal::NanEnableRequest * legacy_request)1494 bool convertHidlNanEnableRequest_1_4ToLegacy(
1495     const V1_4::NanEnableRequest& hidl_request1,
1496     const NanConfigRequestSupplemental& hidl_request2,
1497     legacy_hal::NanEnableRequest* legacy_request) {
1498     if (!legacy_request) {
1499         LOG(ERROR)
1500             << "convertHidlNanEnableRequest_1_4ToLegacy: null legacy_request";
1501         return false;
1502     }
1503 
1504     *legacy_request = {};
1505     if (!convertHidlNanEnableRequestToLegacy(hidl_request1, legacy_request)) {
1506         return false;
1507     }
1508 
1509     legacy_request->config_discovery_beacon_int = 1;
1510     legacy_request->discovery_beacon_interval =
1511         hidl_request2.V1_2.discoveryBeaconIntervalMs;
1512     legacy_request->config_nss = 1;
1513     legacy_request->nss = hidl_request2.V1_2.numberOfSpatialStreamsInDiscovery;
1514     legacy_request->config_dw_early_termination = 1;
1515     legacy_request->enable_dw_termination =
1516         hidl_request2.V1_2.enableDiscoveryWindowEarlyTermination;
1517     legacy_request->config_enable_ranging = 1;
1518     legacy_request->enable_ranging = hidl_request2.V1_2.enableRanging;
1519 
1520     return true;
1521 }
1522 
convertHidlNanEnableRequest_1_5ToLegacy(const V1_4::NanEnableRequest & hidl_request1,const NanConfigRequestSupplemental & hidl_request2,legacy_hal::NanEnableRequest * legacy_request)1523 bool convertHidlNanEnableRequest_1_5ToLegacy(
1524     const V1_4::NanEnableRequest& hidl_request1,
1525     const NanConfigRequestSupplemental& hidl_request2,
1526     legacy_hal::NanEnableRequest* legacy_request) {
1527     if (!legacy_request) {
1528         LOG(ERROR)
1529             << "convertHidlNanEnableRequest_1_5ToLegacy: null legacy_request";
1530         return false;
1531     }
1532 
1533     *legacy_request = {};
1534     if (!convertHidlNanEnableRequest_1_4ToLegacy(hidl_request1, hidl_request2,
1535                                                  legacy_request)) {
1536         return false;
1537     }
1538 
1539     legacy_request->config_enable_instant_mode = 1;
1540     legacy_request->enable_instant_mode =
1541         hidl_request2.enableInstantCommunicationMode;
1542 
1543     return true;
1544 }
1545 
convertHidlNanConfigRequest_1_5ToLegacy(const V1_4::NanConfigRequest & hidl_request1,const NanConfigRequestSupplemental & hidl_request2,legacy_hal::NanConfigRequest * legacy_request)1546 bool convertHidlNanConfigRequest_1_5ToLegacy(
1547     const V1_4::NanConfigRequest& hidl_request1,
1548     const NanConfigRequestSupplemental& hidl_request2,
1549     legacy_hal::NanConfigRequest* legacy_request) {
1550     if (!legacy_request) {
1551         LOG(ERROR)
1552             << "convertHidlNanConfigRequest_1_5ToLegacy: null legacy_request";
1553         return false;
1554     }
1555 
1556     *legacy_request = {};
1557     if (!convertHidlNanConfigRequest_1_4ToLegacy(hidl_request1, hidl_request2,
1558                                                  legacy_request)) {
1559         return false;
1560     }
1561 
1562     legacy_request->config_enable_instant_mode = 1;
1563     legacy_request->enable_instant_mode =
1564         hidl_request2.enableInstantCommunicationMode;
1565 
1566     return true;
1567 }
1568 
convertHidlNanPublishRequestToLegacy(const NanPublishRequest & hidl_request,legacy_hal::NanPublishRequest * legacy_request)1569 bool convertHidlNanPublishRequestToLegacy(
1570     const NanPublishRequest& hidl_request,
1571     legacy_hal::NanPublishRequest* legacy_request) {
1572     if (!legacy_request) {
1573         LOG(ERROR)
1574             << "convertHidlNanPublishRequestToLegacy: null legacy_request";
1575         return false;
1576     }
1577     *legacy_request = {};
1578 
1579     legacy_request->publish_id = hidl_request.baseConfigs.sessionId;
1580     legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
1581     legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
1582     legacy_request->publish_count = hidl_request.baseConfigs.discoveryCount;
1583     legacy_request->service_name_len =
1584         hidl_request.baseConfigs.serviceName.size();
1585     if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1586         LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: service_name_len "
1587                       "too large";
1588         return false;
1589     }
1590     memcpy(legacy_request->service_name,
1591            hidl_request.baseConfigs.serviceName.data(),
1592            legacy_request->service_name_len);
1593     legacy_request->publish_match_indicator = convertHidlNanMatchAlgToLegacy(
1594         hidl_request.baseConfigs.discoveryMatchIndicator);
1595     legacy_request->service_specific_info_len =
1596         hidl_request.baseConfigs.serviceSpecificInfo.size();
1597     if (legacy_request->service_specific_info_len >
1598         NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1599         LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1600                       "service_specific_info_len too large";
1601         return false;
1602     }
1603     memcpy(legacy_request->service_specific_info,
1604            hidl_request.baseConfigs.serviceSpecificInfo.data(),
1605            legacy_request->service_specific_info_len);
1606     legacy_request->sdea_service_specific_info_len =
1607         hidl_request.baseConfigs.extendedServiceSpecificInfo.size();
1608     if (legacy_request->sdea_service_specific_info_len >
1609         NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1610         LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1611                       "sdea_service_specific_info_len too large";
1612         return false;
1613     }
1614     memcpy(legacy_request->sdea_service_specific_info,
1615            hidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
1616            legacy_request->sdea_service_specific_info_len);
1617     legacy_request->rx_match_filter_len =
1618         hidl_request.baseConfigs.rxMatchFilter.size();
1619     if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1620         LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1621                       "rx_match_filter_len too large";
1622         return false;
1623     }
1624     memcpy(legacy_request->rx_match_filter,
1625            hidl_request.baseConfigs.rxMatchFilter.data(),
1626            legacy_request->rx_match_filter_len);
1627     legacy_request->tx_match_filter_len =
1628         hidl_request.baseConfigs.txMatchFilter.size();
1629     if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1630         LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1631                       "tx_match_filter_len too large";
1632         return false;
1633     }
1634     memcpy(legacy_request->tx_match_filter,
1635            hidl_request.baseConfigs.txMatchFilter.data(),
1636            legacy_request->tx_match_filter_len);
1637     legacy_request->rssi_threshold_flag =
1638         hidl_request.baseConfigs.useRssiThreshold;
1639     legacy_request->recv_indication_cfg = 0;
1640     legacy_request->recv_indication_cfg |=
1641         hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1
1642                                                                        : 0x0;
1643     legacy_request->recv_indication_cfg |=
1644         hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
1645     legacy_request->recv_indication_cfg |=
1646         hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
1647     legacy_request->recv_indication_cfg |= 0x8;
1648     legacy_request->cipher_type =
1649         (unsigned int)hidl_request.baseConfigs.securityConfig.cipherType;
1650     if (hidl_request.baseConfigs.securityConfig.securityType ==
1651         NanDataPathSecurityType::PMK) {
1652         legacy_request->key_info.key_type =
1653             legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1654         legacy_request->key_info.body.pmk_info.pmk_len =
1655             hidl_request.baseConfigs.securityConfig.pmk.size();
1656         if (legacy_request->key_info.body.pmk_info.pmk_len !=
1657             NAN_PMK_INFO_LEN) {
1658             LOG(ERROR)
1659                 << "convertHidlNanPublishRequestToLegacy: invalid pmk_len";
1660             return false;
1661         }
1662         memcpy(legacy_request->key_info.body.pmk_info.pmk,
1663                hidl_request.baseConfigs.securityConfig.pmk.data(),
1664                legacy_request->key_info.body.pmk_info.pmk_len);
1665     }
1666     if (hidl_request.baseConfigs.securityConfig.securityType ==
1667         NanDataPathSecurityType::PASSPHRASE) {
1668         legacy_request->key_info.key_type =
1669             legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1670         legacy_request->key_info.body.passphrase_info.passphrase_len =
1671             hidl_request.baseConfigs.securityConfig.passphrase.size();
1672         if (legacy_request->key_info.body.passphrase_info.passphrase_len <
1673             NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1674             LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1675                           "passphrase_len too small";
1676             return false;
1677         }
1678         if (legacy_request->key_info.body.passphrase_info.passphrase_len >
1679             NAN_SECURITY_MAX_PASSPHRASE_LEN) {
1680             LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1681                           "passphrase_len too large";
1682             return false;
1683         }
1684         memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1685                hidl_request.baseConfigs.securityConfig.passphrase.data(),
1686                legacy_request->key_info.body.passphrase_info.passphrase_len);
1687     }
1688     legacy_request->sdea_params.security_cfg =
1689         (hidl_request.baseConfigs.securityConfig.securityType !=
1690          NanDataPathSecurityType::OPEN)
1691             ? legacy_hal::NAN_DP_CONFIG_SECURITY
1692             : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
1693     legacy_request->sdea_params.ranging_state =
1694         hidl_request.baseConfigs.rangingRequired
1695             ? legacy_hal::NAN_RANGING_ENABLE
1696             : legacy_hal::NAN_RANGING_DISABLE;
1697     legacy_request->ranging_cfg.ranging_interval_msec =
1698         hidl_request.baseConfigs.rangingIntervalMsec;
1699     legacy_request->ranging_cfg.config_ranging_indications =
1700         hidl_request.baseConfigs.configRangingIndications;
1701     legacy_request->ranging_cfg.distance_ingress_mm =
1702         hidl_request.baseConfigs.distanceIngressCm * 10;
1703     legacy_request->ranging_cfg.distance_egress_mm =
1704         hidl_request.baseConfigs.distanceEgressCm * 10;
1705     legacy_request->ranging_auto_response =
1706         hidl_request.baseConfigs.rangingRequired
1707             ? legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE
1708             : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
1709     legacy_request->sdea_params.range_report =
1710         legacy_hal::NAN_DISABLE_RANGE_REPORT;
1711     legacy_request->publish_type =
1712         convertHidlNanPublishTypeToLegacy(hidl_request.publishType);
1713     legacy_request->tx_type = convertHidlNanTxTypeToLegacy(hidl_request.txType);
1714     legacy_request->service_responder_policy =
1715         hidl_request.autoAcceptDataPathRequests
1716             ? legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL
1717             : legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE;
1718 
1719     return true;
1720 }
1721 
convertHidlNanSubscribeRequestToLegacy(const NanSubscribeRequest & hidl_request,legacy_hal::NanSubscribeRequest * legacy_request)1722 bool convertHidlNanSubscribeRequestToLegacy(
1723     const NanSubscribeRequest& hidl_request,
1724     legacy_hal::NanSubscribeRequest* legacy_request) {
1725     if (!legacy_request) {
1726         LOG(ERROR)
1727             << "convertHidlNanSubscribeRequestToLegacy: legacy_request is null";
1728         return false;
1729     }
1730     *legacy_request = {};
1731 
1732     legacy_request->subscribe_id = hidl_request.baseConfigs.sessionId;
1733     legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
1734     legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
1735     legacy_request->subscribe_count = hidl_request.baseConfigs.discoveryCount;
1736     legacy_request->service_name_len =
1737         hidl_request.baseConfigs.serviceName.size();
1738     if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1739         LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1740                       "service_name_len too large";
1741         return false;
1742     }
1743     memcpy(legacy_request->service_name,
1744            hidl_request.baseConfigs.serviceName.data(),
1745            legacy_request->service_name_len);
1746     legacy_request->subscribe_match_indicator = convertHidlNanMatchAlgToLegacy(
1747         hidl_request.baseConfigs.discoveryMatchIndicator);
1748     legacy_request->service_specific_info_len =
1749         hidl_request.baseConfigs.serviceSpecificInfo.size();
1750     if (legacy_request->service_specific_info_len >
1751         NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1752         LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1753                       "service_specific_info_len too large";
1754         return false;
1755     }
1756     memcpy(legacy_request->service_specific_info,
1757            hidl_request.baseConfigs.serviceSpecificInfo.data(),
1758            legacy_request->service_specific_info_len);
1759     legacy_request->sdea_service_specific_info_len =
1760         hidl_request.baseConfigs.extendedServiceSpecificInfo.size();
1761     if (legacy_request->sdea_service_specific_info_len >
1762         NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1763         LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1764                       "sdea_service_specific_info_len too large";
1765         return false;
1766     }
1767     memcpy(legacy_request->sdea_service_specific_info,
1768            hidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
1769            legacy_request->sdea_service_specific_info_len);
1770     legacy_request->rx_match_filter_len =
1771         hidl_request.baseConfigs.rxMatchFilter.size();
1772     if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1773         LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1774                       "rx_match_filter_len too large";
1775         return false;
1776     }
1777     memcpy(legacy_request->rx_match_filter,
1778            hidl_request.baseConfigs.rxMatchFilter.data(),
1779            legacy_request->rx_match_filter_len);
1780     legacy_request->tx_match_filter_len =
1781         hidl_request.baseConfigs.txMatchFilter.size();
1782     if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1783         LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1784                       "tx_match_filter_len too large";
1785         return false;
1786     }
1787     memcpy(legacy_request->tx_match_filter,
1788            hidl_request.baseConfigs.txMatchFilter.data(),
1789            legacy_request->tx_match_filter_len);
1790     legacy_request->rssi_threshold_flag =
1791         hidl_request.baseConfigs.useRssiThreshold;
1792     legacy_request->recv_indication_cfg = 0;
1793     legacy_request->recv_indication_cfg |=
1794         hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1
1795                                                                        : 0x0;
1796     legacy_request->recv_indication_cfg |=
1797         hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
1798     legacy_request->recv_indication_cfg |=
1799         hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
1800     legacy_request->cipher_type =
1801         (unsigned int)hidl_request.baseConfigs.securityConfig.cipherType;
1802     if (hidl_request.baseConfigs.securityConfig.securityType ==
1803         NanDataPathSecurityType::PMK) {
1804         legacy_request->key_info.key_type =
1805             legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1806         legacy_request->key_info.body.pmk_info.pmk_len =
1807             hidl_request.baseConfigs.securityConfig.pmk.size();
1808         if (legacy_request->key_info.body.pmk_info.pmk_len !=
1809             NAN_PMK_INFO_LEN) {
1810             LOG(ERROR)
1811                 << "convertHidlNanSubscribeRequestToLegacy: invalid pmk_len";
1812             return false;
1813         }
1814         memcpy(legacy_request->key_info.body.pmk_info.pmk,
1815                hidl_request.baseConfigs.securityConfig.pmk.data(),
1816                legacy_request->key_info.body.pmk_info.pmk_len);
1817     }
1818     if (hidl_request.baseConfigs.securityConfig.securityType ==
1819         NanDataPathSecurityType::PASSPHRASE) {
1820         legacy_request->key_info.key_type =
1821             legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1822         legacy_request->key_info.body.passphrase_info.passphrase_len =
1823             hidl_request.baseConfigs.securityConfig.passphrase.size();
1824         if (legacy_request->key_info.body.passphrase_info.passphrase_len <
1825             NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1826             LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1827                           "passphrase_len too small";
1828             return false;
1829         }
1830         if (legacy_request->key_info.body.passphrase_info.passphrase_len >
1831             NAN_SECURITY_MAX_PASSPHRASE_LEN) {
1832             LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1833                           "passphrase_len too large";
1834             return false;
1835         }
1836         memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1837                hidl_request.baseConfigs.securityConfig.passphrase.data(),
1838                legacy_request->key_info.body.passphrase_info.passphrase_len);
1839     }
1840     legacy_request->sdea_params.security_cfg =
1841         (hidl_request.baseConfigs.securityConfig.securityType !=
1842          NanDataPathSecurityType::OPEN)
1843             ? legacy_hal::NAN_DP_CONFIG_SECURITY
1844             : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
1845     legacy_request->sdea_params.ranging_state =
1846         hidl_request.baseConfigs.rangingRequired
1847             ? legacy_hal::NAN_RANGING_ENABLE
1848             : legacy_hal::NAN_RANGING_DISABLE;
1849     legacy_request->ranging_cfg.ranging_interval_msec =
1850         hidl_request.baseConfigs.rangingIntervalMsec;
1851     legacy_request->ranging_cfg.config_ranging_indications =
1852         hidl_request.baseConfigs.configRangingIndications;
1853     legacy_request->ranging_cfg.distance_ingress_mm =
1854         hidl_request.baseConfigs.distanceIngressCm * 10;
1855     legacy_request->ranging_cfg.distance_egress_mm =
1856         hidl_request.baseConfigs.distanceEgressCm * 10;
1857     legacy_request->ranging_auto_response =
1858         hidl_request.baseConfigs.rangingRequired
1859             ? legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE
1860             : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
1861     legacy_request->sdea_params.range_report =
1862         legacy_hal::NAN_DISABLE_RANGE_REPORT;
1863     legacy_request->subscribe_type =
1864         convertHidlNanSubscribeTypeToLegacy(hidl_request.subscribeType);
1865     legacy_request->serviceResponseFilter =
1866         convertHidlNanSrfTypeToLegacy(hidl_request.srfType);
1867     legacy_request->serviceResponseInclude =
1868         hidl_request.srfRespondIfInAddressSet
1869             ? legacy_hal::NAN_SRF_INCLUDE_RESPOND
1870             : legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
1871     legacy_request->useServiceResponseFilter =
1872         hidl_request.shouldUseSrf ? legacy_hal::NAN_USE_SRF
1873                                   : legacy_hal::NAN_DO_NOT_USE_SRF;
1874     legacy_request->ssiRequiredForMatchIndication =
1875         hidl_request.isSsiRequiredForMatch
1876             ? legacy_hal::NAN_SSI_REQUIRED_IN_MATCH_IND
1877             : legacy_hal::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND;
1878     legacy_request->num_intf_addr_present = hidl_request.intfAddr.size();
1879     if (legacy_request->num_intf_addr_present > NAN_MAX_SUBSCRIBE_MAX_ADDRESS) {
1880         LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1881                       "num_intf_addr_present - too many";
1882         return false;
1883     }
1884     for (int i = 0; i < legacy_request->num_intf_addr_present; i++) {
1885         memcpy(legacy_request->intf_addr[i], hidl_request.intfAddr[i].data(),
1886                6);
1887     }
1888 
1889     return true;
1890 }
1891 
convertHidlNanTransmitFollowupRequestToLegacy(const NanTransmitFollowupRequest & hidl_request,legacy_hal::NanTransmitFollowupRequest * legacy_request)1892 bool convertHidlNanTransmitFollowupRequestToLegacy(
1893     const NanTransmitFollowupRequest& hidl_request,
1894     legacy_hal::NanTransmitFollowupRequest* legacy_request) {
1895     if (!legacy_request) {
1896         LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
1897                       "legacy_request is null";
1898         return false;
1899     }
1900     *legacy_request = {};
1901 
1902     legacy_request->publish_subscribe_id = hidl_request.discoverySessionId;
1903     legacy_request->requestor_instance_id = hidl_request.peerId;
1904     memcpy(legacy_request->addr, hidl_request.addr.data(), 6);
1905     legacy_request->priority = hidl_request.isHighPriority
1906                                    ? legacy_hal::NAN_TX_PRIORITY_HIGH
1907                                    : legacy_hal::NAN_TX_PRIORITY_NORMAL;
1908     legacy_request->dw_or_faw = hidl_request.shouldUseDiscoveryWindow
1909                                     ? legacy_hal::NAN_TRANSMIT_IN_DW
1910                                     : legacy_hal::NAN_TRANSMIT_IN_FAW;
1911     legacy_request->service_specific_info_len =
1912         hidl_request.serviceSpecificInfo.size();
1913     if (legacy_request->service_specific_info_len >
1914         NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1915         LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
1916                       "service_specific_info_len too large";
1917         return false;
1918     }
1919     memcpy(legacy_request->service_specific_info,
1920            hidl_request.serviceSpecificInfo.data(),
1921            legacy_request->service_specific_info_len);
1922     legacy_request->sdea_service_specific_info_len =
1923         hidl_request.extendedServiceSpecificInfo.size();
1924     if (legacy_request->sdea_service_specific_info_len >
1925         NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1926         LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
1927                       "sdea_service_specific_info_len too large";
1928         return false;
1929     }
1930     memcpy(legacy_request->sdea_service_specific_info,
1931            hidl_request.extendedServiceSpecificInfo.data(),
1932            legacy_request->sdea_service_specific_info_len);
1933     legacy_request->recv_indication_cfg =
1934         hidl_request.disableFollowupResultIndication ? 0x1 : 0x0;
1935 
1936     return true;
1937 }
1938 
convertHidlNanConfigRequestToLegacy(const V1_4::NanConfigRequest & hidl_request,legacy_hal::NanConfigRequest * legacy_request)1939 bool convertHidlNanConfigRequestToLegacy(
1940     const V1_4::NanConfigRequest& hidl_request,
1941     legacy_hal::NanConfigRequest* legacy_request) {
1942     if (!legacy_request) {
1943         LOG(ERROR)
1944             << "convertHidlNanConfigRequestToLegacy: legacy_request is null";
1945         return false;
1946     }
1947     *legacy_request = {};
1948 
1949     // TODO: b/34059183 tracks missing configurations in legacy HAL or uknown
1950     // defaults
1951     legacy_request->master_pref = hidl_request.masterPref;
1952     legacy_request->discovery_indication_cfg = 0;
1953     legacy_request->discovery_indication_cfg |=
1954         hidl_request.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
1955     legacy_request->discovery_indication_cfg |=
1956         hidl_request.disableStartedClusterIndication ? 0x2 : 0x0;
1957     legacy_request->discovery_indication_cfg |=
1958         hidl_request.disableJoinedClusterIndication ? 0x4 : 0x0;
1959     legacy_request->config_sid_beacon = 1;
1960     if (hidl_request.numberOfPublishServiceIdsInBeacon > 127) {
1961         LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: "
1962                       "numberOfPublishServiceIdsInBeacon > 127";
1963         return false;
1964     }
1965     legacy_request->sid_beacon =
1966         (hidl_request.includePublishServiceIdsInBeacon ? 0x1 : 0x0) |
1967         (hidl_request.numberOfPublishServiceIdsInBeacon << 1);
1968     legacy_request->config_subscribe_sid_beacon = 1;
1969     if (hidl_request.numberOfSubscribeServiceIdsInBeacon > 127) {
1970         LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: "
1971                       "numberOfSubscribeServiceIdsInBeacon > 127";
1972         return false;
1973     }
1974     legacy_request->subscribe_sid_beacon_val =
1975         (hidl_request.includeSubscribeServiceIdsInBeacon ? 0x1 : 0x0) |
1976         (hidl_request.numberOfSubscribeServiceIdsInBeacon << 1);
1977     legacy_request->config_rssi_window_size = 1;
1978     legacy_request->rssi_window_size_val = hidl_request.rssiWindowSize;
1979     legacy_request->config_disc_mac_addr_randomization = 1;
1980     legacy_request->disc_mac_addr_rand_interval_sec =
1981         hidl_request.macAddressRandomizationIntervalSec;
1982     /* TODO : missing
1983     legacy_request->config_2dot4g_rssi_close = 1;
1984     legacy_request->rssi_close_2dot4g_val =
1985           hidl_request.bandSpecificConfig[
1986               (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiClose;
1987     legacy_request->config_2dot4g_rssi_middle = 1;
1988     legacy_request->rssi_middle_2dot4g_val =
1989           hidl_request.bandSpecificConfig[
1990               (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiMiddle;
1991     legacy_request->config_2dot4g_rssi_proximity = 1;
1992     legacy_request->rssi_proximity_2dot4g_val =
1993           hidl_request.bandSpecificConfig[
1994               (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiCloseProximity;
1995     */
1996     legacy_request->config_scan_params = 1;
1997     legacy_request->scan_params_val
1998         .dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
1999         hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
2000             .dwellTimeMs;
2001     legacy_request->scan_params_val
2002         .scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
2003         hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
2004             .scanPeriodSec;
2005     legacy_request->config_dw.config_2dot4g_dw_band =
2006         hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
2007             .validDiscoveryWindowIntervalVal;
2008     legacy_request->config_dw.dw_2dot4g_interval_val =
2009         hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
2010             .discoveryWindowIntervalVal;
2011     /* TODO: missing
2012     legacy_request->config_5g_rssi_close = 1;
2013     legacy_request->rssi_close_5g_val =
2014           hidl_request.bandSpecificConfig[
2015               (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiClose;
2016     legacy_request->config_5g_rssi_middle = 1;
2017     legacy_request->rssi_middle_5g_val =
2018           hidl_request.bandSpecificConfig[
2019               (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiMiddle;
2020     */
2021     legacy_request->config_5g_rssi_close_proximity = 1;
2022     legacy_request->rssi_close_proximity_5g_val =
2023         hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
2024             .rssiCloseProximity;
2025     legacy_request->scan_params_val
2026         .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
2027         hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
2028             .dwellTimeMs;
2029     legacy_request->scan_params_val
2030         .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
2031         hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
2032             .scanPeriodSec;
2033     legacy_request->scan_params_val
2034         .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
2035         hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
2036             .dwellTimeMs;
2037     legacy_request->scan_params_val
2038         .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
2039         hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
2040             .scanPeriodSec;
2041     legacy_request->config_dw.config_5g_dw_band =
2042         hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
2043             .validDiscoveryWindowIntervalVal;
2044     legacy_request->config_dw.dw_5g_interval_val =
2045         hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
2046             .discoveryWindowIntervalVal;
2047     /* TODO: b/145609058
2048      * Missing updates needed to legacy_hal::NanConfigRequest and conversion to
2049      * it for 6GHz band */
2050 
2051     return true;
2052 }
2053 
convertHidlNanConfigRequest_1_4ToLegacy(const V1_4::NanConfigRequest & hidl_request1,const NanConfigRequestSupplemental & hidl_request2,legacy_hal::NanConfigRequest * legacy_request)2054 bool convertHidlNanConfigRequest_1_4ToLegacy(
2055     const V1_4::NanConfigRequest& hidl_request1,
2056     const NanConfigRequestSupplemental& hidl_request2,
2057     legacy_hal::NanConfigRequest* legacy_request) {
2058     if (!legacy_request) {
2059         LOG(ERROR) << "convertHidlNanConfigRequest_1_4ToLegacy: legacy_request "
2060                       "is null";
2061         return false;
2062     }
2063 
2064     *legacy_request = {};
2065     if (!convertHidlNanConfigRequestToLegacy(hidl_request1, legacy_request)) {
2066         return false;
2067     }
2068 
2069     legacy_request->config_discovery_beacon_int = 1;
2070     legacy_request->discovery_beacon_interval =
2071         hidl_request2.V1_2.discoveryBeaconIntervalMs;
2072     legacy_request->config_nss = 1;
2073     legacy_request->nss = hidl_request2.V1_2.numberOfSpatialStreamsInDiscovery;
2074     legacy_request->config_dw_early_termination = 1;
2075     legacy_request->enable_dw_termination =
2076         hidl_request2.V1_2.enableDiscoveryWindowEarlyTermination;
2077     legacy_request->config_enable_ranging = 1;
2078     legacy_request->enable_ranging = hidl_request2.V1_2.enableRanging;
2079 
2080     return true;
2081 }
2082 
convertHidlNanDataPathInitiatorRequestToLegacy(const NanInitiateDataPathRequest & hidl_request,legacy_hal::NanDataPathInitiatorRequest * legacy_request)2083 bool convertHidlNanDataPathInitiatorRequestToLegacy(
2084     const NanInitiateDataPathRequest& hidl_request,
2085     legacy_hal::NanDataPathInitiatorRequest* legacy_request) {
2086     if (!legacy_request) {
2087         LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
2088                       "legacy_request is null";
2089         return false;
2090     }
2091     *legacy_request = {};
2092 
2093     legacy_request->requestor_instance_id = hidl_request.peerId;
2094     memcpy(legacy_request->peer_disc_mac_addr,
2095            hidl_request.peerDiscMacAddr.data(), 6);
2096     legacy_request->channel_request_type =
2097         convertHidlNanDataPathChannelCfgToLegacy(
2098             hidl_request.channelRequestType);
2099     legacy_request->channel = hidl_request.channel;
2100     if (strnlen(hidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
2101         LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
2102                       "ifaceName too long";
2103         return false;
2104     }
2105     strncpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str(),
2106             IFNAMSIZ + 1);
2107     legacy_request->ndp_cfg.security_cfg =
2108         (hidl_request.securityConfig.securityType !=
2109          NanDataPathSecurityType::OPEN)
2110             ? legacy_hal::NAN_DP_CONFIG_SECURITY
2111             : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
2112     legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
2113     if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
2114         LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
2115                       "ndp_app_info_len too large";
2116         return false;
2117     }
2118     memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
2119            legacy_request->app_info.ndp_app_info_len);
2120     legacy_request->cipher_type =
2121         (unsigned int)hidl_request.securityConfig.cipherType;
2122     if (hidl_request.securityConfig.securityType ==
2123         NanDataPathSecurityType::PMK) {
2124         legacy_request->key_info.key_type =
2125             legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
2126         legacy_request->key_info.body.pmk_info.pmk_len =
2127             hidl_request.securityConfig.pmk.size();
2128         if (legacy_request->key_info.body.pmk_info.pmk_len !=
2129             NAN_PMK_INFO_LEN) {
2130             LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
2131                           "invalid pmk_len";
2132             return false;
2133         }
2134         memcpy(legacy_request->key_info.body.pmk_info.pmk,
2135                hidl_request.securityConfig.pmk.data(),
2136                legacy_request->key_info.body.pmk_info.pmk_len);
2137     }
2138     if (hidl_request.securityConfig.securityType ==
2139         NanDataPathSecurityType::PASSPHRASE) {
2140         legacy_request->key_info.key_type =
2141             legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
2142         legacy_request->key_info.body.passphrase_info.passphrase_len =
2143             hidl_request.securityConfig.passphrase.size();
2144         if (legacy_request->key_info.body.passphrase_info.passphrase_len <
2145             NAN_SECURITY_MIN_PASSPHRASE_LEN) {
2146             LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
2147                           "passphrase_len too small";
2148             return false;
2149         }
2150         if (legacy_request->key_info.body.passphrase_info.passphrase_len >
2151             NAN_SECURITY_MAX_PASSPHRASE_LEN) {
2152             LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
2153                           "passphrase_len too large";
2154             return false;
2155         }
2156         memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
2157                hidl_request.securityConfig.passphrase.data(),
2158                legacy_request->key_info.body.passphrase_info.passphrase_len);
2159     }
2160     legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
2161     if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
2162         LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
2163                       "service_name_len too large";
2164         return false;
2165     }
2166     memcpy(legacy_request->service_name,
2167            hidl_request.serviceNameOutOfBand.data(),
2168            legacy_request->service_name_len);
2169 
2170     return true;
2171 }
2172 
convertHidlNanDataPathIndicationResponseToLegacy(const NanRespondToDataPathIndicationRequest & hidl_request,legacy_hal::NanDataPathIndicationResponse * legacy_request)2173 bool convertHidlNanDataPathIndicationResponseToLegacy(
2174     const NanRespondToDataPathIndicationRequest& hidl_request,
2175     legacy_hal::NanDataPathIndicationResponse* legacy_request) {
2176     if (!legacy_request) {
2177         LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2178                       "legacy_request is null";
2179         return false;
2180     }
2181     *legacy_request = {};
2182 
2183     legacy_request->rsp_code = hidl_request.acceptRequest
2184                                    ? legacy_hal::NAN_DP_REQUEST_ACCEPT
2185                                    : legacy_hal::NAN_DP_REQUEST_REJECT;
2186     legacy_request->ndp_instance_id = hidl_request.ndpInstanceId;
2187     if (strnlen(hidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
2188         LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2189                       "ifaceName too long";
2190         return false;
2191     }
2192     strncpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str(),
2193             IFNAMSIZ + 1);
2194     legacy_request->ndp_cfg.security_cfg =
2195         (hidl_request.securityConfig.securityType !=
2196          NanDataPathSecurityType::OPEN)
2197             ? legacy_hal::NAN_DP_CONFIG_SECURITY
2198             : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
2199     legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
2200     if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
2201         LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2202                       "ndp_app_info_len too large";
2203         return false;
2204     }
2205     memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
2206            legacy_request->app_info.ndp_app_info_len);
2207     legacy_request->cipher_type =
2208         (unsigned int)hidl_request.securityConfig.cipherType;
2209     if (hidl_request.securityConfig.securityType ==
2210         NanDataPathSecurityType::PMK) {
2211         legacy_request->key_info.key_type =
2212             legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
2213         legacy_request->key_info.body.pmk_info.pmk_len =
2214             hidl_request.securityConfig.pmk.size();
2215         if (legacy_request->key_info.body.pmk_info.pmk_len !=
2216             NAN_PMK_INFO_LEN) {
2217             LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2218                           "invalid pmk_len";
2219             return false;
2220         }
2221         memcpy(legacy_request->key_info.body.pmk_info.pmk,
2222                hidl_request.securityConfig.pmk.data(),
2223                legacy_request->key_info.body.pmk_info.pmk_len);
2224     }
2225     if (hidl_request.securityConfig.securityType ==
2226         NanDataPathSecurityType::PASSPHRASE) {
2227         legacy_request->key_info.key_type =
2228             legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
2229         legacy_request->key_info.body.passphrase_info.passphrase_len =
2230             hidl_request.securityConfig.passphrase.size();
2231         if (legacy_request->key_info.body.passphrase_info.passphrase_len <
2232             NAN_SECURITY_MIN_PASSPHRASE_LEN) {
2233             LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2234                           "passphrase_len too small";
2235             return false;
2236         }
2237         if (legacy_request->key_info.body.passphrase_info.passphrase_len >
2238             NAN_SECURITY_MAX_PASSPHRASE_LEN) {
2239             LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2240                           "passphrase_len too large";
2241             return false;
2242         }
2243         memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
2244                hidl_request.securityConfig.passphrase.data(),
2245                legacy_request->key_info.body.passphrase_info.passphrase_len);
2246     }
2247     legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
2248     if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
2249         LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2250                       "service_name_len too large";
2251         return false;
2252     }
2253     memcpy(legacy_request->service_name,
2254            hidl_request.serviceNameOutOfBand.data(),
2255            legacy_request->service_name_len);
2256 
2257     return true;
2258 }
2259 
convertLegacyNanResponseHeaderToHidl(const legacy_hal::NanResponseMsg & legacy_response,WifiNanStatus * wifiNanStatus)2260 bool convertLegacyNanResponseHeaderToHidl(
2261     const legacy_hal::NanResponseMsg& legacy_response,
2262     WifiNanStatus* wifiNanStatus) {
2263     if (!wifiNanStatus) {
2264         LOG(ERROR)
2265             << "convertLegacyNanResponseHeaderToHidl: wifiNanStatus is null";
2266         return false;
2267     }
2268     *wifiNanStatus = {};
2269 
2270     convertToWifiNanStatus(legacy_response.status, legacy_response.nan_error,
2271                            sizeof(legacy_response.nan_error), wifiNanStatus);
2272     return true;
2273 }
2274 
convertLegacyNanCapabilitiesResponseToHidl(const legacy_hal::NanCapabilities & legacy_response,NanCapabilities * hidl_response)2275 bool convertLegacyNanCapabilitiesResponseToHidl(
2276     const legacy_hal::NanCapabilities& legacy_response,
2277     NanCapabilities* hidl_response) {
2278     if (!hidl_response) {
2279         LOG(ERROR) << "convertLegacyNanCapabilitiesResponseToHidl: "
2280                       "hidl_response is null";
2281         return false;
2282     }
2283     *hidl_response = {};
2284 
2285     hidl_response->V1_0.maxConcurrentClusters =
2286         legacy_response.max_concurrent_nan_clusters;
2287     hidl_response->V1_0.maxPublishes = legacy_response.max_publishes;
2288     hidl_response->V1_0.maxSubscribes = legacy_response.max_subscribes;
2289     hidl_response->V1_0.maxServiceNameLen =
2290         legacy_response.max_service_name_len;
2291     hidl_response->V1_0.maxMatchFilterLen =
2292         legacy_response.max_match_filter_len;
2293     hidl_response->V1_0.maxTotalMatchFilterLen =
2294         legacy_response.max_total_match_filter_len;
2295     hidl_response->V1_0.maxServiceSpecificInfoLen =
2296         legacy_response.max_service_specific_info_len;
2297     hidl_response->V1_0.maxExtendedServiceSpecificInfoLen =
2298         legacy_response.max_sdea_service_specific_info_len;
2299     hidl_response->V1_0.maxNdiInterfaces = legacy_response.max_ndi_interfaces;
2300     hidl_response->V1_0.maxNdpSessions = legacy_response.max_ndp_sessions;
2301     hidl_response->V1_0.maxAppInfoLen = legacy_response.max_app_info_len;
2302     hidl_response->V1_0.maxQueuedTransmitFollowupMsgs =
2303         legacy_response.max_queued_transmit_followup_msgs;
2304     hidl_response->V1_0.maxSubscribeInterfaceAddresses =
2305         legacy_response.max_subscribe_address;
2306     hidl_response->V1_0.supportedCipherSuites =
2307         legacy_response.cipher_suites_supported;
2308     hidl_response->instantCommunicationModeSupportFlag =
2309         legacy_response.is_instant_mode_supported;
2310 
2311     return true;
2312 }
2313 
convertLegacyNanMatchIndToHidl(const legacy_hal::NanMatchInd & legacy_ind,NanMatchInd * hidl_ind)2314 bool convertLegacyNanMatchIndToHidl(const legacy_hal::NanMatchInd& legacy_ind,
2315                                     NanMatchInd* hidl_ind) {
2316     if (!hidl_ind) {
2317         LOG(ERROR) << "convertLegacyNanMatchIndToHidl: hidl_ind is null";
2318         return false;
2319     }
2320     *hidl_ind = {};
2321 
2322     hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
2323     hidl_ind->peerId = legacy_ind.requestor_instance_id;
2324     hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
2325     hidl_ind->serviceSpecificInfo =
2326         std::vector<uint8_t>(legacy_ind.service_specific_info,
2327                              legacy_ind.service_specific_info +
2328                                  legacy_ind.service_specific_info_len);
2329     hidl_ind->extendedServiceSpecificInfo =
2330         std::vector<uint8_t>(legacy_ind.sdea_service_specific_info,
2331                              legacy_ind.sdea_service_specific_info +
2332                                  legacy_ind.sdea_service_specific_info_len);
2333     hidl_ind->matchFilter = std::vector<uint8_t>(
2334         legacy_ind.sdf_match_filter,
2335         legacy_ind.sdf_match_filter + legacy_ind.sdf_match_filter_len);
2336     hidl_ind->matchOccuredInBeaconFlag = legacy_ind.match_occured_flag == 1;
2337     hidl_ind->outOfResourceFlag = legacy_ind.out_of_resource_flag == 1;
2338     hidl_ind->rssiValue = legacy_ind.rssi_value;
2339     hidl_ind->peerCipherType = (NanCipherSuiteType)legacy_ind.peer_cipher_type;
2340     hidl_ind->peerRequiresSecurityEnabledInNdp =
2341         legacy_ind.peer_sdea_params.security_cfg ==
2342         legacy_hal::NAN_DP_CONFIG_SECURITY;
2343     hidl_ind->peerRequiresRanging = legacy_ind.peer_sdea_params.ranging_state ==
2344                                     legacy_hal::NAN_RANGING_ENABLE;
2345     hidl_ind->rangingMeasurementInCm =
2346         legacy_ind.range_info.range_measurement_mm / 10;
2347     hidl_ind->rangingIndicationType = legacy_ind.range_info.ranging_event_type;
2348 
2349     return true;
2350 }
2351 
convertLegacyNanFollowupIndToHidl(const legacy_hal::NanFollowupInd & legacy_ind,NanFollowupReceivedInd * hidl_ind)2352 bool convertLegacyNanFollowupIndToHidl(
2353     const legacy_hal::NanFollowupInd& legacy_ind,
2354     NanFollowupReceivedInd* hidl_ind) {
2355     if (!hidl_ind) {
2356         LOG(ERROR) << "convertLegacyNanFollowupIndToHidl: hidl_ind is null";
2357         return false;
2358     }
2359     *hidl_ind = {};
2360 
2361     hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
2362     hidl_ind->peerId = legacy_ind.requestor_instance_id;
2363     hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
2364     hidl_ind->receivedInFaw = legacy_ind.dw_or_faw == 1;
2365     hidl_ind->serviceSpecificInfo =
2366         std::vector<uint8_t>(legacy_ind.service_specific_info,
2367                              legacy_ind.service_specific_info +
2368                                  legacy_ind.service_specific_info_len);
2369     hidl_ind->extendedServiceSpecificInfo =
2370         std::vector<uint8_t>(legacy_ind.sdea_service_specific_info,
2371                              legacy_ind.sdea_service_specific_info +
2372                                  legacy_ind.sdea_service_specific_info_len);
2373 
2374     return true;
2375 }
2376 
convertLegacyNanDataPathRequestIndToHidl(const legacy_hal::NanDataPathRequestInd & legacy_ind,NanDataPathRequestInd * hidl_ind)2377 bool convertLegacyNanDataPathRequestIndToHidl(
2378     const legacy_hal::NanDataPathRequestInd& legacy_ind,
2379     NanDataPathRequestInd* hidl_ind) {
2380     if (!hidl_ind) {
2381         LOG(ERROR)
2382             << "convertLegacyNanDataPathRequestIndToHidl: hidl_ind is null";
2383         return false;
2384     }
2385     *hidl_ind = {};
2386 
2387     hidl_ind->discoverySessionId = legacy_ind.service_instance_id;
2388     hidl_ind->peerDiscMacAddr =
2389         hidl_array<uint8_t, 6>(legacy_ind.peer_disc_mac_addr);
2390     hidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
2391     hidl_ind->securityRequired =
2392         legacy_ind.ndp_cfg.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
2393     hidl_ind->appInfo =
2394         std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info,
2395                              legacy_ind.app_info.ndp_app_info +
2396                                  legacy_ind.app_info.ndp_app_info_len);
2397 
2398     return true;
2399 }
2400 
convertLegacyNdpChannelInfoToHidl(const legacy_hal::NanChannelInfo & legacy_struct,V1_2::NanDataPathChannelInfo * hidl_struct)2401 bool convertLegacyNdpChannelInfoToHidl(
2402     const legacy_hal::NanChannelInfo& legacy_struct,
2403     V1_2::NanDataPathChannelInfo* hidl_struct) {
2404     if (!hidl_struct) {
2405         LOG(ERROR) << "convertLegacyNdpChannelInfoToHidl: hidl_struct is null";
2406         return false;
2407     }
2408     *hidl_struct = {};
2409 
2410     hidl_struct->channelFreq = legacy_struct.channel;
2411     hidl_struct->channelBandwidth = convertLegacyWifiChannelWidthToHidl(
2412         (legacy_hal::wifi_channel_width)legacy_struct.bandwidth);
2413     hidl_struct->numSpatialStreams = legacy_struct.nss;
2414 
2415     return true;
2416 }
2417 
convertLegacyNanDataPathConfirmIndToHidl(const legacy_hal::NanDataPathConfirmInd & legacy_ind,V1_2::NanDataPathConfirmInd * hidl_ind)2418 bool convertLegacyNanDataPathConfirmIndToHidl(
2419     const legacy_hal::NanDataPathConfirmInd& legacy_ind,
2420     V1_2::NanDataPathConfirmInd* hidl_ind) {
2421     if (!hidl_ind) {
2422         LOG(ERROR)
2423             << "convertLegacyNanDataPathConfirmIndToHidl: hidl_ind is null";
2424         return false;
2425     }
2426     *hidl_ind = {};
2427 
2428     hidl_ind->V1_0.ndpInstanceId = legacy_ind.ndp_instance_id;
2429     hidl_ind->V1_0.dataPathSetupSuccess =
2430         legacy_ind.rsp_code == legacy_hal::NAN_DP_REQUEST_ACCEPT;
2431     hidl_ind->V1_0.peerNdiMacAddr =
2432         hidl_array<uint8_t, 6>(legacy_ind.peer_ndi_mac_addr);
2433     hidl_ind->V1_0.appInfo =
2434         std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info,
2435                              legacy_ind.app_info.ndp_app_info +
2436                                  legacy_ind.app_info.ndp_app_info_len);
2437     hidl_ind->V1_0.status.status =
2438         convertLegacyNanStatusTypeToHidl(legacy_ind.reason_code);
2439     hidl_ind->V1_0.status.description = "";  // TODO: b/34059183
2440 
2441     std::vector<V1_2::NanDataPathChannelInfo> channelInfo;
2442     for (unsigned int i = 0; i < legacy_ind.num_channels; ++i) {
2443         V1_2::NanDataPathChannelInfo hidl_struct;
2444         if (!convertLegacyNdpChannelInfoToHidl(legacy_ind.channel_info[i],
2445                                                &hidl_struct)) {
2446             return false;
2447         }
2448         channelInfo.push_back(hidl_struct);
2449     }
2450     hidl_ind->channelInfo = channelInfo;
2451 
2452     return true;
2453 }
2454 
convertLegacyNanDataPathScheduleUpdateIndToHidl(const legacy_hal::NanDataPathScheduleUpdateInd & legacy_ind,V1_2::NanDataPathScheduleUpdateInd * hidl_ind)2455 bool convertLegacyNanDataPathScheduleUpdateIndToHidl(
2456     const legacy_hal::NanDataPathScheduleUpdateInd& legacy_ind,
2457     V1_2::NanDataPathScheduleUpdateInd* hidl_ind) {
2458     if (!hidl_ind) {
2459         LOG(ERROR) << "convertLegacyNanDataPathScheduleUpdateIndToHidl: "
2460                       "hidl_ind is null";
2461         return false;
2462     }
2463     *hidl_ind = {};
2464 
2465     hidl_ind->peerDiscoveryAddress =
2466         hidl_array<uint8_t, 6>(legacy_ind.peer_mac_addr);
2467     std::vector<V1_2::NanDataPathChannelInfo> channelInfo;
2468     for (unsigned int i = 0; i < legacy_ind.num_channels; ++i) {
2469         V1_2::NanDataPathChannelInfo hidl_struct;
2470         if (!convertLegacyNdpChannelInfoToHidl(legacy_ind.channel_info[i],
2471                                                &hidl_struct)) {
2472             return false;
2473         }
2474         channelInfo.push_back(hidl_struct);
2475     }
2476     hidl_ind->channelInfo = channelInfo;
2477     std::vector<uint32_t> ndpInstanceIds;
2478     for (unsigned int i = 0; i < legacy_ind.num_ndp_instances; ++i) {
2479         ndpInstanceIds.push_back(legacy_ind.ndp_instance_id[i]);
2480     }
2481     hidl_ind->ndpInstanceIds = ndpInstanceIds;
2482 
2483     return true;
2484 }
2485 
convertHidlRttTypeToLegacy(RttType type)2486 legacy_hal::wifi_rtt_type convertHidlRttTypeToLegacy(RttType type) {
2487     switch (type) {
2488         case RttType::ONE_SIDED:
2489             return legacy_hal::RTT_TYPE_1_SIDED;
2490         case RttType::TWO_SIDED:
2491             return legacy_hal::RTT_TYPE_2_SIDED;
2492     };
2493     CHECK(false);
2494 }
2495 
convertLegacyRttTypeToHidl(legacy_hal::wifi_rtt_type type)2496 RttType convertLegacyRttTypeToHidl(legacy_hal::wifi_rtt_type type) {
2497     switch (type) {
2498         case legacy_hal::RTT_TYPE_1_SIDED:
2499             return RttType::ONE_SIDED;
2500         case legacy_hal::RTT_TYPE_2_SIDED:
2501             return RttType::TWO_SIDED;
2502     };
2503     CHECK(false) << "Unknown legacy type: " << type;
2504 }
2505 
convertHidlRttPeerTypeToLegacy(RttPeerType type)2506 legacy_hal::rtt_peer_type convertHidlRttPeerTypeToLegacy(RttPeerType type) {
2507     switch (type) {
2508         case RttPeerType::AP:
2509             return legacy_hal::RTT_PEER_AP;
2510         case RttPeerType::STA:
2511             return legacy_hal::RTT_PEER_STA;
2512         case RttPeerType::P2P_GO:
2513             return legacy_hal::RTT_PEER_P2P_GO;
2514         case RttPeerType::P2P_CLIENT:
2515             return legacy_hal::RTT_PEER_P2P_CLIENT;
2516         case RttPeerType::NAN:
2517             return legacy_hal::RTT_PEER_NAN;
2518     };
2519     CHECK(false);
2520 }
2521 
convertHidlWifiChannelWidthToLegacy(WifiChannelWidthInMhz type)2522 legacy_hal::wifi_channel_width convertHidlWifiChannelWidthToLegacy(
2523     WifiChannelWidthInMhz type) {
2524     switch (type) {
2525         case WifiChannelWidthInMhz::WIDTH_20:
2526             return legacy_hal::WIFI_CHAN_WIDTH_20;
2527         case WifiChannelWidthInMhz::WIDTH_40:
2528             return legacy_hal::WIFI_CHAN_WIDTH_40;
2529         case WifiChannelWidthInMhz::WIDTH_80:
2530             return legacy_hal::WIFI_CHAN_WIDTH_80;
2531         case WifiChannelWidthInMhz::WIDTH_160:
2532             return legacy_hal::WIFI_CHAN_WIDTH_160;
2533         case WifiChannelWidthInMhz::WIDTH_80P80:
2534             return legacy_hal::WIFI_CHAN_WIDTH_80P80;
2535         case WifiChannelWidthInMhz::WIDTH_5:
2536             return legacy_hal::WIFI_CHAN_WIDTH_5;
2537         case WifiChannelWidthInMhz::WIDTH_10:
2538             return legacy_hal::WIFI_CHAN_WIDTH_10;
2539         case WifiChannelWidthInMhz::WIDTH_INVALID:
2540             return legacy_hal::WIFI_CHAN_WIDTH_INVALID;
2541     };
2542     CHECK(false);
2543 }
2544 
convertLegacyWifiChannelWidthToHidl(legacy_hal::wifi_channel_width type)2545 WifiChannelWidthInMhz convertLegacyWifiChannelWidthToHidl(
2546     legacy_hal::wifi_channel_width type) {
2547     switch (type) {
2548         case legacy_hal::WIFI_CHAN_WIDTH_20:
2549             return WifiChannelWidthInMhz::WIDTH_20;
2550         case legacy_hal::WIFI_CHAN_WIDTH_40:
2551             return WifiChannelWidthInMhz::WIDTH_40;
2552         case legacy_hal::WIFI_CHAN_WIDTH_80:
2553             return WifiChannelWidthInMhz::WIDTH_80;
2554         case legacy_hal::WIFI_CHAN_WIDTH_160:
2555             return WifiChannelWidthInMhz::WIDTH_160;
2556         case legacy_hal::WIFI_CHAN_WIDTH_80P80:
2557             return WifiChannelWidthInMhz::WIDTH_80P80;
2558         case legacy_hal::WIFI_CHAN_WIDTH_5:
2559             return WifiChannelWidthInMhz::WIDTH_5;
2560         case legacy_hal::WIFI_CHAN_WIDTH_10:
2561             return WifiChannelWidthInMhz::WIDTH_10;
2562         default:
2563             return WifiChannelWidthInMhz::WIDTH_INVALID;
2564     };
2565 }
2566 
convertHidlRttPreambleToLegacy(V1_4::RttPreamble type)2567 legacy_hal::wifi_rtt_preamble convertHidlRttPreambleToLegacy(
2568     V1_4::RttPreamble type) {
2569     switch (type) {
2570         case V1_4::RttPreamble::LEGACY:
2571             return legacy_hal::WIFI_RTT_PREAMBLE_LEGACY;
2572         case V1_4::RttPreamble::HT:
2573             return legacy_hal::WIFI_RTT_PREAMBLE_HT;
2574         case V1_4::RttPreamble::VHT:
2575             return legacy_hal::WIFI_RTT_PREAMBLE_VHT;
2576         case V1_4::RttPreamble::HE:
2577             return legacy_hal::WIFI_RTT_PREAMBLE_HE;
2578     };
2579     CHECK(false);
2580 }
2581 
convertLegacyRttPreambleToHidl(legacy_hal::wifi_rtt_preamble type)2582 V1_4::RttPreamble convertLegacyRttPreambleToHidl(
2583     legacy_hal::wifi_rtt_preamble type) {
2584     switch (type) {
2585         case legacy_hal::WIFI_RTT_PREAMBLE_LEGACY:
2586             return V1_4::RttPreamble::LEGACY;
2587         case legacy_hal::WIFI_RTT_PREAMBLE_HT:
2588             return V1_4::RttPreamble::HT;
2589         case legacy_hal::WIFI_RTT_PREAMBLE_VHT:
2590             return V1_4::RttPreamble::VHT;
2591         case legacy_hal::WIFI_RTT_PREAMBLE_HE:
2592             return V1_4::RttPreamble::HE;
2593     };
2594     CHECK(false) << "Unknown legacy type: " << type;
2595 }
2596 
convertHidlRttBwToLegacy(RttBw type)2597 legacy_hal::wifi_rtt_bw convertHidlRttBwToLegacy(RttBw type) {
2598     switch (type) {
2599         case RttBw::BW_5MHZ:
2600             return legacy_hal::WIFI_RTT_BW_5;
2601         case RttBw::BW_10MHZ:
2602             return legacy_hal::WIFI_RTT_BW_10;
2603         case RttBw::BW_20MHZ:
2604             return legacy_hal::WIFI_RTT_BW_20;
2605         case RttBw::BW_40MHZ:
2606             return legacy_hal::WIFI_RTT_BW_40;
2607         case RttBw::BW_80MHZ:
2608             return legacy_hal::WIFI_RTT_BW_80;
2609         case RttBw::BW_160MHZ:
2610             return legacy_hal::WIFI_RTT_BW_160;
2611     };
2612     CHECK(false);
2613 }
2614 
convertLegacyRttBwToHidl(legacy_hal::wifi_rtt_bw type)2615 RttBw convertLegacyRttBwToHidl(legacy_hal::wifi_rtt_bw type) {
2616     switch (type) {
2617         case legacy_hal::WIFI_RTT_BW_5:
2618             return RttBw::BW_5MHZ;
2619         case legacy_hal::WIFI_RTT_BW_10:
2620             return RttBw::BW_10MHZ;
2621         case legacy_hal::WIFI_RTT_BW_20:
2622             return RttBw::BW_20MHZ;
2623         case legacy_hal::WIFI_RTT_BW_40:
2624             return RttBw::BW_40MHZ;
2625         case legacy_hal::WIFI_RTT_BW_80:
2626             return RttBw::BW_80MHZ;
2627         case legacy_hal::WIFI_RTT_BW_160:
2628             return RttBw::BW_160MHZ;
2629     };
2630     CHECK(false) << "Unknown legacy type: " << type;
2631 }
2632 
convertHidlRttMotionPatternToLegacy(RttMotionPattern type)2633 legacy_hal::wifi_motion_pattern convertHidlRttMotionPatternToLegacy(
2634     RttMotionPattern type) {
2635     switch (type) {
2636         case RttMotionPattern::NOT_EXPECTED:
2637             return legacy_hal::WIFI_MOTION_NOT_EXPECTED;
2638         case RttMotionPattern::EXPECTED:
2639             return legacy_hal::WIFI_MOTION_EXPECTED;
2640         case RttMotionPattern::UNKNOWN:
2641             return legacy_hal::WIFI_MOTION_UNKNOWN;
2642     };
2643     CHECK(false);
2644 }
2645 
convertLegacyWifiRatePreambleToHidl(uint8_t preamble)2646 V1_4::WifiRatePreamble convertLegacyWifiRatePreambleToHidl(uint8_t preamble) {
2647     switch (preamble) {
2648         case 0:
2649             return V1_4::WifiRatePreamble::OFDM;
2650         case 1:
2651             return V1_4::WifiRatePreamble::CCK;
2652         case 2:
2653             return V1_4::WifiRatePreamble::HT;
2654         case 3:
2655             return V1_4::WifiRatePreamble::VHT;
2656         case 4:
2657             return V1_4::WifiRatePreamble::HE;
2658         default:
2659             return V1_4::WifiRatePreamble::RESERVED;
2660     };
2661     CHECK(false) << "Unknown legacy preamble: " << preamble;
2662 }
2663 
convertLegacyWifiRateNssToHidl(uint8_t nss)2664 WifiRateNss convertLegacyWifiRateNssToHidl(uint8_t nss) {
2665     switch (nss) {
2666         case 0:
2667             return WifiRateNss::NSS_1x1;
2668         case 1:
2669             return WifiRateNss::NSS_2x2;
2670         case 2:
2671             return WifiRateNss::NSS_3x3;
2672         case 3:
2673             return WifiRateNss::NSS_4x4;
2674     };
2675     CHECK(false) << "Unknown legacy nss: " << nss;
2676     return {};
2677 }
2678 
convertLegacyRttStatusToHidl(legacy_hal::wifi_rtt_status status)2679 RttStatus convertLegacyRttStatusToHidl(legacy_hal::wifi_rtt_status status) {
2680     switch (status) {
2681         case legacy_hal::RTT_STATUS_SUCCESS:
2682             return RttStatus::SUCCESS;
2683         case legacy_hal::RTT_STATUS_FAILURE:
2684             return RttStatus::FAILURE;
2685         case legacy_hal::RTT_STATUS_FAIL_NO_RSP:
2686             return RttStatus::FAIL_NO_RSP;
2687         case legacy_hal::RTT_STATUS_FAIL_REJECTED:
2688             return RttStatus::FAIL_REJECTED;
2689         case legacy_hal::RTT_STATUS_FAIL_NOT_SCHEDULED_YET:
2690             return RttStatus::FAIL_NOT_SCHEDULED_YET;
2691         case legacy_hal::RTT_STATUS_FAIL_TM_TIMEOUT:
2692             return RttStatus::FAIL_TM_TIMEOUT;
2693         case legacy_hal::RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL:
2694             return RttStatus::FAIL_AP_ON_DIFF_CHANNEL;
2695         case legacy_hal::RTT_STATUS_FAIL_NO_CAPABILITY:
2696             return RttStatus::FAIL_NO_CAPABILITY;
2697         case legacy_hal::RTT_STATUS_ABORTED:
2698             return RttStatus::ABORTED;
2699         case legacy_hal::RTT_STATUS_FAIL_INVALID_TS:
2700             return RttStatus::FAIL_INVALID_TS;
2701         case legacy_hal::RTT_STATUS_FAIL_PROTOCOL:
2702             return RttStatus::FAIL_PROTOCOL;
2703         case legacy_hal::RTT_STATUS_FAIL_SCHEDULE:
2704             return RttStatus::FAIL_SCHEDULE;
2705         case legacy_hal::RTT_STATUS_FAIL_BUSY_TRY_LATER:
2706             return RttStatus::FAIL_BUSY_TRY_LATER;
2707         case legacy_hal::RTT_STATUS_INVALID_REQ:
2708             return RttStatus::INVALID_REQ;
2709         case legacy_hal::RTT_STATUS_NO_WIFI:
2710             return RttStatus::NO_WIFI;
2711         case legacy_hal::RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE:
2712             return RttStatus::FAIL_FTM_PARAM_OVERRIDE;
2713         case legacy_hal::RTT_STATUS_NAN_RANGING_PROTOCOL_FAILURE:
2714             return RttStatus::FAILURE;  // TODO: add HIDL enumeration
2715         case legacy_hal::RTT_STATUS_NAN_RANGING_CONCURRENCY_NOT_SUPPORTED:
2716             return RttStatus::FAILURE;  // TODO: add HIDL enumeration
2717     };
2718     CHECK(false) << "Unknown legacy status: " << status;
2719 }
2720 
convertHidlWifiChannelInfoToLegacy(const WifiChannelInfo & hidl_info,legacy_hal::wifi_channel_info * legacy_info)2721 bool convertHidlWifiChannelInfoToLegacy(
2722     const WifiChannelInfo& hidl_info,
2723     legacy_hal::wifi_channel_info* legacy_info) {
2724     if (!legacy_info) {
2725         return false;
2726     }
2727     *legacy_info = {};
2728     legacy_info->width = convertHidlWifiChannelWidthToLegacy(hidl_info.width);
2729     legacy_info->center_freq = hidl_info.centerFreq;
2730     legacy_info->center_freq0 = hidl_info.centerFreq0;
2731     legacy_info->center_freq1 = hidl_info.centerFreq1;
2732     return true;
2733 }
2734 
convertLegacyWifiChannelInfoToHidl(const legacy_hal::wifi_channel_info & legacy_info,WifiChannelInfo * hidl_info)2735 bool convertLegacyWifiChannelInfoToHidl(
2736     const legacy_hal::wifi_channel_info& legacy_info,
2737     WifiChannelInfo* hidl_info) {
2738     if (!hidl_info) {
2739         return false;
2740     }
2741     *hidl_info = {};
2742     hidl_info->width = convertLegacyWifiChannelWidthToHidl(legacy_info.width);
2743     hidl_info->centerFreq = legacy_info.center_freq;
2744     hidl_info->centerFreq0 = legacy_info.center_freq0;
2745     hidl_info->centerFreq1 = legacy_info.center_freq1;
2746     return true;
2747 }
2748 
convertHidlRttConfigToLegacy(const V1_4::RttConfig & hidl_config,legacy_hal::wifi_rtt_config * legacy_config)2749 bool convertHidlRttConfigToLegacy(const V1_4::RttConfig& hidl_config,
2750                                   legacy_hal::wifi_rtt_config* legacy_config) {
2751     if (!legacy_config) {
2752         return false;
2753     }
2754     *legacy_config = {};
2755     CHECK(hidl_config.addr.size() == sizeof(legacy_config->addr));
2756     memcpy(legacy_config->addr, hidl_config.addr.data(),
2757            hidl_config.addr.size());
2758     legacy_config->type = convertHidlRttTypeToLegacy(hidl_config.type);
2759     legacy_config->peer = convertHidlRttPeerTypeToLegacy(hidl_config.peer);
2760     if (!convertHidlWifiChannelInfoToLegacy(hidl_config.channel,
2761                                             &legacy_config->channel)) {
2762         return false;
2763     }
2764     legacy_config->burst_period = hidl_config.burstPeriod;
2765     legacy_config->num_burst = hidl_config.numBurst;
2766     legacy_config->num_frames_per_burst = hidl_config.numFramesPerBurst;
2767     legacy_config->num_retries_per_rtt_frame =
2768         hidl_config.numRetriesPerRttFrame;
2769     legacy_config->num_retries_per_ftmr = hidl_config.numRetriesPerFtmr;
2770     legacy_config->LCI_request = hidl_config.mustRequestLci;
2771     legacy_config->LCR_request = hidl_config.mustRequestLcr;
2772     legacy_config->burst_duration = hidl_config.burstDuration;
2773     legacy_config->preamble =
2774         convertHidlRttPreambleToLegacy(hidl_config.preamble);
2775     legacy_config->bw = convertHidlRttBwToLegacy(hidl_config.bw);
2776     return true;
2777 }
2778 
convertHidlVectorOfRttConfigToLegacy(const std::vector<V1_4::RttConfig> & hidl_configs,std::vector<legacy_hal::wifi_rtt_config> * legacy_configs)2779 bool convertHidlVectorOfRttConfigToLegacy(
2780     const std::vector<V1_4::RttConfig>& hidl_configs,
2781     std::vector<legacy_hal::wifi_rtt_config>* legacy_configs) {
2782     if (!legacy_configs) {
2783         return false;
2784     }
2785     *legacy_configs = {};
2786     for (const auto& hidl_config : hidl_configs) {
2787         legacy_hal::wifi_rtt_config legacy_config;
2788         if (!convertHidlRttConfigToLegacy(hidl_config, &legacy_config)) {
2789             return false;
2790         }
2791         legacy_configs->push_back(legacy_config);
2792     }
2793     return true;
2794 }
2795 
convertHidlRttLciInformationToLegacy(const RttLciInformation & hidl_info,legacy_hal::wifi_lci_information * legacy_info)2796 bool convertHidlRttLciInformationToLegacy(
2797     const RttLciInformation& hidl_info,
2798     legacy_hal::wifi_lci_information* legacy_info) {
2799     if (!legacy_info) {
2800         return false;
2801     }
2802     *legacy_info = {};
2803     legacy_info->latitude = hidl_info.latitude;
2804     legacy_info->longitude = hidl_info.longitude;
2805     legacy_info->altitude = hidl_info.altitude;
2806     legacy_info->latitude_unc = hidl_info.latitudeUnc;
2807     legacy_info->longitude_unc = hidl_info.longitudeUnc;
2808     legacy_info->altitude_unc = hidl_info.altitudeUnc;
2809     legacy_info->motion_pattern =
2810         convertHidlRttMotionPatternToLegacy(hidl_info.motionPattern);
2811     legacy_info->floor = hidl_info.floor;
2812     legacy_info->height_above_floor = hidl_info.heightAboveFloor;
2813     legacy_info->height_unc = hidl_info.heightUnc;
2814     return true;
2815 }
2816 
convertHidlRttLcrInformationToLegacy(const RttLcrInformation & hidl_info,legacy_hal::wifi_lcr_information * legacy_info)2817 bool convertHidlRttLcrInformationToLegacy(
2818     const RttLcrInformation& hidl_info,
2819     legacy_hal::wifi_lcr_information* legacy_info) {
2820     if (!legacy_info) {
2821         return false;
2822     }
2823     *legacy_info = {};
2824     CHECK(hidl_info.countryCode.size() == sizeof(legacy_info->country_code));
2825     memcpy(legacy_info->country_code, hidl_info.countryCode.data(),
2826            hidl_info.countryCode.size());
2827     if (hidl_info.civicInfo.size() > sizeof(legacy_info->civic_info)) {
2828         return false;
2829     }
2830     legacy_info->length = hidl_info.civicInfo.size();
2831     memcpy(legacy_info->civic_info, hidl_info.civicInfo.c_str(),
2832            hidl_info.civicInfo.size());
2833     return true;
2834 }
2835 
convertHidlRttResponderToLegacy(const V1_4::RttResponder & hidl_responder,legacy_hal::wifi_rtt_responder * legacy_responder)2836 bool convertHidlRttResponderToLegacy(
2837     const V1_4::RttResponder& hidl_responder,
2838     legacy_hal::wifi_rtt_responder* legacy_responder) {
2839     if (!legacy_responder) {
2840         return false;
2841     }
2842     *legacy_responder = {};
2843     if (!convertHidlWifiChannelInfoToLegacy(hidl_responder.channel,
2844                                             &legacy_responder->channel)) {
2845         return false;
2846     }
2847     legacy_responder->preamble =
2848         convertHidlRttPreambleToLegacy(hidl_responder.preamble);
2849     return true;
2850 }
2851 
convertLegacyRttResponderToHidl(const legacy_hal::wifi_rtt_responder & legacy_responder,V1_4::RttResponder * hidl_responder)2852 bool convertLegacyRttResponderToHidl(
2853     const legacy_hal::wifi_rtt_responder& legacy_responder,
2854     V1_4::RttResponder* hidl_responder) {
2855     if (!hidl_responder) {
2856         return false;
2857     }
2858     *hidl_responder = {};
2859     if (!convertLegacyWifiChannelInfoToHidl(legacy_responder.channel,
2860                                             &hidl_responder->channel)) {
2861         return false;
2862     }
2863     hidl_responder->preamble =
2864         convertLegacyRttPreambleToHidl(legacy_responder.preamble);
2865     return true;
2866 }
2867 
convertLegacyRttCapabilitiesToHidl(const legacy_hal::wifi_rtt_capabilities & legacy_capabilities,V1_4::RttCapabilities * hidl_capabilities)2868 bool convertLegacyRttCapabilitiesToHidl(
2869     const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
2870     V1_4::RttCapabilities* hidl_capabilities) {
2871     if (!hidl_capabilities) {
2872         return false;
2873     }
2874     *hidl_capabilities = {};
2875     hidl_capabilities->rttOneSidedSupported =
2876         legacy_capabilities.rtt_one_sided_supported;
2877     hidl_capabilities->rttFtmSupported = legacy_capabilities.rtt_ftm_supported;
2878     hidl_capabilities->lciSupported = legacy_capabilities.lci_support;
2879     hidl_capabilities->lcrSupported = legacy_capabilities.lcr_support;
2880     hidl_capabilities->responderSupported =
2881         legacy_capabilities.responder_supported;
2882     hidl_capabilities->preambleSupport = 0;
2883     for (const auto flag :
2884          {legacy_hal::WIFI_RTT_PREAMBLE_LEGACY,
2885           legacy_hal::WIFI_RTT_PREAMBLE_HT, legacy_hal::WIFI_RTT_PREAMBLE_VHT,
2886           legacy_hal::WIFI_RTT_PREAMBLE_HE}) {
2887         if (legacy_capabilities.preamble_support & flag) {
2888             hidl_capabilities->preambleSupport |=
2889                 static_cast<std::underlying_type<V1_4::RttPreamble>::type>(
2890                     convertLegacyRttPreambleToHidl(flag));
2891         }
2892     }
2893     hidl_capabilities->bwSupport = 0;
2894     for (const auto flag :
2895          {legacy_hal::WIFI_RTT_BW_5, legacy_hal::WIFI_RTT_BW_10,
2896           legacy_hal::WIFI_RTT_BW_20, legacy_hal::WIFI_RTT_BW_40,
2897           legacy_hal::WIFI_RTT_BW_80, legacy_hal::WIFI_RTT_BW_160}) {
2898         if (legacy_capabilities.bw_support & flag) {
2899             hidl_capabilities->bwSupport |=
2900                 static_cast<std::underlying_type<RttBw>::type>(
2901                     convertLegacyRttBwToHidl(flag));
2902         }
2903     }
2904     hidl_capabilities->mcVersion = legacy_capabilities.mc_version;
2905     return true;
2906 }
2907 
convertLegacyWifiRateInfoToHidl(const legacy_hal::wifi_rate & legacy_rate,V1_4::WifiRateInfo * hidl_rate)2908 bool convertLegacyWifiRateInfoToHidl(const legacy_hal::wifi_rate& legacy_rate,
2909                                      V1_4::WifiRateInfo* hidl_rate) {
2910     if (!hidl_rate) {
2911         return false;
2912     }
2913     *hidl_rate = {};
2914     hidl_rate->preamble =
2915         convertLegacyWifiRatePreambleToHidl(legacy_rate.preamble);
2916     hidl_rate->nss = convertLegacyWifiRateNssToHidl(legacy_rate.nss);
2917     hidl_rate->bw = convertLegacyWifiChannelWidthToHidl(
2918         static_cast<legacy_hal::wifi_channel_width>(legacy_rate.bw));
2919     hidl_rate->rateMcsIdx = legacy_rate.rateMcsIdx;
2920     hidl_rate->bitRateInKbps = legacy_rate.bitrate;
2921     return true;
2922 }
2923 
convertLegacyRttResultToHidl(const legacy_hal::wifi_rtt_result & legacy_result,V1_4::RttResult * hidl_result)2924 bool convertLegacyRttResultToHidl(
2925     const legacy_hal::wifi_rtt_result& legacy_result,
2926     V1_4::RttResult* hidl_result) {
2927     if (!hidl_result) {
2928         return false;
2929     }
2930     *hidl_result = {};
2931     CHECK(sizeof(legacy_result.addr) == hidl_result->addr.size());
2932     memcpy(hidl_result->addr.data(), legacy_result.addr,
2933            sizeof(legacy_result.addr));
2934     hidl_result->burstNum = legacy_result.burst_num;
2935     hidl_result->measurementNumber = legacy_result.measurement_number;
2936     hidl_result->successNumber = legacy_result.success_number;
2937     hidl_result->numberPerBurstPeer = legacy_result.number_per_burst_peer;
2938     hidl_result->status = convertLegacyRttStatusToHidl(legacy_result.status);
2939     hidl_result->retryAfterDuration = legacy_result.retry_after_duration;
2940     hidl_result->type = convertLegacyRttTypeToHidl(legacy_result.type);
2941     hidl_result->rssi = legacy_result.rssi;
2942     hidl_result->rssiSpread = legacy_result.rssi_spread;
2943     if (!convertLegacyWifiRateInfoToHidl(legacy_result.tx_rate,
2944                                          &hidl_result->txRate)) {
2945         return false;
2946     }
2947     if (!convertLegacyWifiRateInfoToHidl(legacy_result.rx_rate,
2948                                          &hidl_result->rxRate)) {
2949         return false;
2950     }
2951     hidl_result->rtt = legacy_result.rtt;
2952     hidl_result->rttSd = legacy_result.rtt_sd;
2953     hidl_result->rttSpread = legacy_result.rtt_spread;
2954     hidl_result->distanceInMm = legacy_result.distance_mm;
2955     hidl_result->distanceSdInMm = legacy_result.distance_sd_mm;
2956     hidl_result->distanceSpreadInMm = legacy_result.distance_spread_mm;
2957     hidl_result->timeStampInUs = legacy_result.ts;
2958     hidl_result->burstDurationInMs = legacy_result.burst_duration;
2959     hidl_result->negotiatedBurstNum = legacy_result.negotiated_burst_num;
2960     if (legacy_result.LCI &&
2961         !convertLegacyIeToHidl(*legacy_result.LCI, &hidl_result->lci)) {
2962         return false;
2963     }
2964     if (legacy_result.LCR &&
2965         !convertLegacyIeToHidl(*legacy_result.LCR, &hidl_result->lcr)) {
2966         return false;
2967     }
2968     return true;
2969 }
2970 
convertLegacyVectorOfRttResultToHidl(const std::vector<const legacy_hal::wifi_rtt_result * > & legacy_results,std::vector<V1_4::RttResult> * hidl_results)2971 bool convertLegacyVectorOfRttResultToHidl(
2972     const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
2973     std::vector<V1_4::RttResult>* hidl_results) {
2974     if (!hidl_results) {
2975         return false;
2976     }
2977     *hidl_results = {};
2978     for (const auto legacy_result : legacy_results) {
2979         V1_4::RttResult hidl_result;
2980         if (!convertLegacyRttResultToHidl(*legacy_result, &hidl_result)) {
2981             return false;
2982         }
2983         hidl_results->push_back(hidl_result);
2984     }
2985     return true;
2986 }
2987 
convertHidlIfaceTypeToLegacy(IfaceType hidl_interface_type)2988 legacy_hal::wifi_interface_type convertHidlIfaceTypeToLegacy(
2989     IfaceType hidl_interface_type) {
2990     switch (hidl_interface_type) {
2991         case IfaceType::STA:
2992             return legacy_hal::WIFI_INTERFACE_TYPE_STA;
2993         case IfaceType::AP:
2994             return legacy_hal::WIFI_INTERFACE_TYPE_AP;
2995         case IfaceType::P2P:
2996             return legacy_hal::WIFI_INTERFACE_TYPE_P2P;
2997         case IfaceType::NAN:
2998             return legacy_hal::WIFI_INTERFACE_TYPE_NAN;
2999     }
3000     CHECK(false);
3001 }
3002 
convertHidlMultiStaUseCaseToLegacy(IWifiChip::MultiStaUseCase use_case)3003 legacy_hal::wifi_multi_sta_use_case convertHidlMultiStaUseCaseToLegacy(
3004     IWifiChip::MultiStaUseCase use_case) {
3005     switch (use_case) {
3006         case IWifiChip::MultiStaUseCase::DUAL_STA_TRANSIENT_PREFER_PRIMARY:
3007             return legacy_hal::WIFI_DUAL_STA_TRANSIENT_PREFER_PRIMARY;
3008         case IWifiChip::MultiStaUseCase::DUAL_STA_NON_TRANSIENT_UNBIASED:
3009             return legacy_hal::WIFI_DUAL_STA_NON_TRANSIENT_UNBIASED;
3010     }
3011     CHECK(false);
3012 }
3013 
convertHidlCoexUnsafeChannelToLegacy(const IWifiChip::CoexUnsafeChannel & hidl_unsafe_channel,legacy_hal::wifi_coex_unsafe_channel * legacy_unsafe_channel)3014 bool convertHidlCoexUnsafeChannelToLegacy(
3015     const IWifiChip::CoexUnsafeChannel& hidl_unsafe_channel,
3016     legacy_hal::wifi_coex_unsafe_channel* legacy_unsafe_channel) {
3017     if (!legacy_unsafe_channel) {
3018         return false;
3019     }
3020     *legacy_unsafe_channel = {};
3021     switch (hidl_unsafe_channel.band) {
3022         case WifiBand::BAND_24GHZ:
3023             legacy_unsafe_channel->band = legacy_hal::WLAN_MAC_2_4_BAND;
3024             break;
3025         case WifiBand::BAND_5GHZ:
3026             legacy_unsafe_channel->band = legacy_hal::WLAN_MAC_5_0_BAND;
3027             break;
3028         default:
3029             return false;
3030     };
3031     legacy_unsafe_channel->channel = hidl_unsafe_channel.channel;
3032     legacy_unsafe_channel->power_cap_dbm = hidl_unsafe_channel.powerCapDbm;
3033     return true;
3034 }
3035 
convertHidlVectorOfCoexUnsafeChannelToLegacy(const std::vector<IWifiChip::CoexUnsafeChannel> & hidl_unsafe_channels,std::vector<legacy_hal::wifi_coex_unsafe_channel> * legacy_unsafe_channels)3036 bool convertHidlVectorOfCoexUnsafeChannelToLegacy(
3037     const std::vector<IWifiChip::CoexUnsafeChannel>& hidl_unsafe_channels,
3038     std::vector<legacy_hal::wifi_coex_unsafe_channel>* legacy_unsafe_channels) {
3039     if (!legacy_unsafe_channels) {
3040         return false;
3041     }
3042     *legacy_unsafe_channels = {};
3043     for (const auto& hidl_unsafe_channel : hidl_unsafe_channels) {
3044         legacy_hal::wifi_coex_unsafe_channel legacy_unsafe_channel;
3045         if (!hidl_struct_util::convertHidlCoexUnsafeChannelToLegacy(
3046                 hidl_unsafe_channel, &legacy_unsafe_channel)) {
3047             return false;
3048         }
3049         legacy_unsafe_channels->push_back(legacy_unsafe_channel);
3050     }
3051     return true;
3052 }
3053 
3054 }  // namespace hidl_struct_util
3055 }  // namespace implementation
3056 }  // namespace V1_5
3057 }  // namespace wifi
3058 }  // namespace hardware
3059 }  // namespace android
3060