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