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