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