blob: 83d06fe398688dffc6ff134c62ac1978373004d5 [file] [log] [blame]
Roshan Piuse65edb12016-11-22 13:02:01 -08001/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <android-base/logging.h>
18#include <utils/SystemClock.h>
19
20#include "hidl_struct_util.h"
21
22namespace android {
23namespace hardware {
24namespace wifi {
Jimmy Chend460df32019-11-29 17:31:22 +020025namespace V1_5 {
Roshan Piuse65edb12016-11-22 13:02:01 -080026namespace implementation {
27namespace hidl_struct_util {
28
Etan Cohenb1b7a822018-02-07 14:44:32 -080029WifiChannelWidthInMhz convertLegacyWifiChannelWidthToHidl(
30 legacy_hal::wifi_channel_width type);
31
Etan Cohenbbc0f092017-04-26 16:52:34 -070032hidl_string safeConvertChar(const char* str, size_t max_len) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070033 const char* c = str;
34 size_t size = 0;
35 while (*c && (unsigned char)*c < 128 && size < max_len) {
36 ++size;
37 ++c;
38 }
39 return hidl_string(str, size);
Etan Cohenbbc0f092017-04-26 16:52:34 -070040}
41
Roshan Piusf72df2e2016-12-04 10:49:38 -080042IWifiChip::ChipCapabilityMask convertLegacyLoggerFeatureToHidlChipCapability(
43 uint32_t feature) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070044 using HidlChipCaps = IWifiChip::ChipCapabilityMask;
45 switch (feature) {
46 case legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED:
47 return HidlChipCaps::DEBUG_MEMORY_FIRMWARE_DUMP;
48 case legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED:
49 return HidlChipCaps::DEBUG_MEMORY_DRIVER_DUMP;
50 case legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED:
51 return HidlChipCaps::DEBUG_RING_BUFFER_CONNECT_EVENT;
52 case legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED:
53 return HidlChipCaps::DEBUG_RING_BUFFER_POWER_EVENT;
54 case legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED:
55 return HidlChipCaps::DEBUG_RING_BUFFER_WAKELOCK_EVENT;
56 };
57 CHECK(false) << "Unknown legacy feature: " << feature;
58 return {};
Roshan Piusf72df2e2016-12-04 10:49:38 -080059}
60
61IWifiStaIface::StaIfaceCapabilityMask
62convertLegacyLoggerFeatureToHidlStaIfaceCapability(uint32_t feature) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070063 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
64 switch (feature) {
65 case legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED:
66 return HidlStaIfaceCaps::DEBUG_PACKET_FATE;
67 };
68 CHECK(false) << "Unknown legacy feature: " << feature;
69 return {};
Roshan Piusf72df2e2016-12-04 10:49:38 -080070}
71
Jimmy Chen1bdf1a72019-12-23 17:53:40 +020072V1_5::IWifiChip::ChipCapabilityMask convertLegacyFeatureToHidlChipCapability(
73 uint64_t feature) {
74 using HidlChipCaps = V1_5::IWifiChip::ChipCapabilityMask;
Roshan Piusabcf78f2017-10-06 16:30:38 -070075 switch (feature) {
76 case WIFI_FEATURE_SET_TX_POWER_LIMIT:
77 return HidlChipCaps::SET_TX_POWER_LIMIT;
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -080078 case WIFI_FEATURE_USE_BODY_HEAD_SAR:
79 return HidlChipCaps::USE_BODY_HEAD_SAR;
Roshan Piusabcf78f2017-10-06 16:30:38 -070080 case WIFI_FEATURE_D2D_RTT:
81 return HidlChipCaps::D2D_RTT;
82 case WIFI_FEATURE_D2AP_RTT:
83 return HidlChipCaps::D2AP_RTT;
Jimmy Chen1bdf1a72019-12-23 17:53:40 +020084 case WIFI_FEATURE_INFRA_60G:
85 return HidlChipCaps::WIGIG;
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -070086 case WIFI_FEATURE_SET_LATENCY_MODE:
87 return HidlChipCaps::SET_LATENCY_MODE;
Jimmy Chend87a0ee2018-12-14 15:38:58 +080088 case WIFI_FEATURE_P2P_RAND_MAC:
89 return HidlChipCaps::P2P_RAND_MAC;
Roshan Piusabcf78f2017-10-06 16:30:38 -070090 };
91 CHECK(false) << "Unknown legacy feature: " << feature;
92 return {};
Roshan Pius8184d212017-07-11 08:59:29 -070093}
94
Roshan Piusf72df2e2016-12-04 10:49:38 -080095IWifiStaIface::StaIfaceCapabilityMask
Ahmed ElArabawy95e36b72019-11-15 21:24:53 +000096convertLegacyFeatureToHidlStaIfaceCapability(uint64_t feature) {
Roshan Piusabcf78f2017-10-06 16:30:38 -070097 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
98 switch (feature) {
99 case WIFI_FEATURE_GSCAN:
100 return HidlStaIfaceCaps::BACKGROUND_SCAN;
101 case WIFI_FEATURE_LINK_LAYER_STATS:
102 return HidlStaIfaceCaps::LINK_LAYER_STATS;
103 case WIFI_FEATURE_RSSI_MONITOR:
104 return HidlStaIfaceCaps::RSSI_MONITOR;
105 case WIFI_FEATURE_CONTROL_ROAMING:
106 return HidlStaIfaceCaps::CONTROL_ROAMING;
107 case WIFI_FEATURE_IE_WHITELIST:
108 return HidlStaIfaceCaps::PROBE_IE_WHITELIST;
109 case WIFI_FEATURE_SCAN_RAND:
110 return HidlStaIfaceCaps::SCAN_RAND;
111 case WIFI_FEATURE_INFRA_5G:
112 return HidlStaIfaceCaps::STA_5G;
113 case WIFI_FEATURE_HOTSPOT:
114 return HidlStaIfaceCaps::HOTSPOT;
115 case WIFI_FEATURE_PNO:
116 return HidlStaIfaceCaps::PNO;
117 case WIFI_FEATURE_TDLS:
118 return HidlStaIfaceCaps::TDLS;
119 case WIFI_FEATURE_TDLS_OFFCHANNEL:
120 return HidlStaIfaceCaps::TDLS_OFFCHANNEL;
121 case WIFI_FEATURE_CONFIG_NDO:
122 return HidlStaIfaceCaps::ND_OFFLOAD;
123 case WIFI_FEATURE_MKEEP_ALIVE:
124 return HidlStaIfaceCaps::KEEP_ALIVE;
125 };
126 CHECK(false) << "Unknown legacy feature: " << feature;
127 return {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800128}
129
130bool convertLegacyFeaturesToHidlChipCapabilities(
Jimmy Chen1bdf1a72019-12-23 17:53:40 +0200131 uint64_t legacy_feature_set, uint32_t legacy_logger_feature_set,
Roshan Pius8184d212017-07-11 08:59:29 -0700132 uint32_t* hidl_caps) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700133 if (!hidl_caps) {
134 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800135 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700136 *hidl_caps = {};
137 using HidlChipCaps = IWifiChip::ChipCapabilityMask;
138 for (const auto feature : {legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED,
139 legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED,
140 legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED,
141 legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED,
142 legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED}) {
143 if (feature & legacy_logger_feature_set) {
144 *hidl_caps |=
145 convertLegacyLoggerFeatureToHidlChipCapability(feature);
146 }
Roshan Pius8184d212017-07-11 08:59:29 -0700147 }
Jimmy Chen1bdf1a72019-12-23 17:53:40 +0200148 std::vector<uint64_t> features = {WIFI_FEATURE_SET_TX_POWER_LIMIT,
Jimmy Chend87a0ee2018-12-14 15:38:58 +0800149 WIFI_FEATURE_USE_BODY_HEAD_SAR,
150 WIFI_FEATURE_D2D_RTT,
151 WIFI_FEATURE_D2AP_RTT,
Jimmy Chen1bdf1a72019-12-23 17:53:40 +0200152 WIFI_FEATURE_INFRA_60G,
Jimmy Chend87a0ee2018-12-14 15:38:58 +0800153 WIFI_FEATURE_SET_LATENCY_MODE,
154 WIFI_FEATURE_P2P_RAND_MAC};
155 for (const auto feature : features) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700156 if (feature & legacy_feature_set) {
157 *hidl_caps |= convertLegacyFeatureToHidlChipCapability(feature);
158 }
159 }
Jimmy Chend87a0ee2018-12-14 15:38:58 +0800160
Roshan Piusabcf78f2017-10-06 16:30:38 -0700161 // There are no flags for these 3 in the legacy feature set. Adding them to
162 // the set because all the current devices support it.
163 *hidl_caps |= HidlChipCaps::DEBUG_RING_BUFFER_VENDOR_DATA;
164 *hidl_caps |= HidlChipCaps::DEBUG_HOST_WAKE_REASON_STATS;
165 *hidl_caps |= HidlChipCaps::DEBUG_ERROR_ALERTS;
166 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800167}
168
169WifiDebugRingBufferFlags convertLegacyDebugRingBufferFlagsToHidl(
170 uint32_t flag) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700171 switch (flag) {
172 case WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES:
173 return WifiDebugRingBufferFlags::HAS_BINARY_ENTRIES;
174 case WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES:
175 return WifiDebugRingBufferFlags::HAS_ASCII_ENTRIES;
176 };
177 CHECK(false) << "Unknown legacy flag: " << flag;
178 return {};
Roshan Piusf72df2e2016-12-04 10:49:38 -0800179}
180
181bool convertLegacyDebugRingBufferStatusToHidl(
182 const legacy_hal::wifi_ring_buffer_status& legacy_status,
183 WifiDebugRingBufferStatus* hidl_status) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700184 if (!hidl_status) {
185 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800186 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700187 *hidl_status = {};
188 hidl_status->ringName =
189 safeConvertChar(reinterpret_cast<const char*>(legacy_status.name),
190 sizeof(legacy_status.name));
191 hidl_status->flags = 0;
192 for (const auto flag : {WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES,
193 WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES}) {
194 if (flag & legacy_status.flags) {
195 hidl_status->flags |= static_cast<
196 std::underlying_type<WifiDebugRingBufferFlags>::type>(
197 convertLegacyDebugRingBufferFlagsToHidl(flag));
198 }
199 }
200 hidl_status->ringId = legacy_status.ring_id;
201 hidl_status->sizeInBytes = legacy_status.ring_buffer_byte_size;
202 // Calculate free size of the ring the buffer. We don't need to send the
203 // exact read/write pointers that were there in the legacy HAL interface.
204 if (legacy_status.written_bytes >= legacy_status.read_bytes) {
205 hidl_status->freeSizeInBytes =
206 legacy_status.ring_buffer_byte_size -
207 (legacy_status.written_bytes - legacy_status.read_bytes);
208 } else {
209 hidl_status->freeSizeInBytes =
210 legacy_status.read_bytes - legacy_status.written_bytes;
211 }
212 hidl_status->verboseLevel = legacy_status.verbose_level;
213 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800214}
215
216bool convertLegacyVectorOfDebugRingBufferStatusToHidl(
217 const std::vector<legacy_hal::wifi_ring_buffer_status>& legacy_status_vec,
218 std::vector<WifiDebugRingBufferStatus>* hidl_status_vec) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700219 if (!hidl_status_vec) {
220 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800221 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700222 *hidl_status_vec = {};
223 for (const auto& legacy_status : legacy_status_vec) {
224 WifiDebugRingBufferStatus hidl_status;
225 if (!convertLegacyDebugRingBufferStatusToHidl(legacy_status,
226 &hidl_status)) {
227 return false;
228 }
229 hidl_status_vec->push_back(hidl_status);
230 }
231 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800232}
233
234bool convertLegacyWakeReasonStatsToHidl(
235 const legacy_hal::WakeReasonStats& legacy_stats,
236 WifiDebugHostWakeReasonStats* hidl_stats) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700237 if (!hidl_stats) {
238 return false;
239 }
240 *hidl_stats = {};
241 hidl_stats->totalCmdEventWakeCnt =
242 legacy_stats.wake_reason_cnt.total_cmd_event_wake;
243 hidl_stats->cmdEventWakeCntPerType = legacy_stats.cmd_event_wake_cnt;
244 hidl_stats->totalDriverFwLocalWakeCnt =
245 legacy_stats.wake_reason_cnt.total_driver_fw_local_wake;
246 hidl_stats->driverFwLocalWakeCntPerType =
247 legacy_stats.driver_fw_local_wake_cnt;
248 hidl_stats->totalRxPacketWakeCnt =
249 legacy_stats.wake_reason_cnt.total_rx_data_wake;
250 hidl_stats->rxPktWakeDetails.rxUnicastCnt =
251 legacy_stats.wake_reason_cnt.rx_wake_details.rx_unicast_cnt;
252 hidl_stats->rxPktWakeDetails.rxMulticastCnt =
253 legacy_stats.wake_reason_cnt.rx_wake_details.rx_multicast_cnt;
254 hidl_stats->rxPktWakeDetails.rxBroadcastCnt =
255 legacy_stats.wake_reason_cnt.rx_wake_details.rx_broadcast_cnt;
256 hidl_stats->rxMulticastPkWakeDetails.ipv4RxMulticastAddrCnt =
257 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
258 .ipv4_rx_multicast_addr_cnt;
259 hidl_stats->rxMulticastPkWakeDetails.ipv6RxMulticastAddrCnt =
260 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
261 .ipv6_rx_multicast_addr_cnt;
262 hidl_stats->rxMulticastPkWakeDetails.otherRxMulticastAddrCnt =
263 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info
264 .other_rx_multicast_addr_cnt;
265 hidl_stats->rxIcmpPkWakeDetails.icmpPkt =
266 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp_pkt;
267 hidl_stats->rxIcmpPkWakeDetails.icmp6Pkt =
268 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_pkt;
269 hidl_stats->rxIcmpPkWakeDetails.icmp6Ra =
270 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ra;
271 hidl_stats->rxIcmpPkWakeDetails.icmp6Na =
272 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_na;
273 hidl_stats->rxIcmpPkWakeDetails.icmp6Ns =
274 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ns;
275 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800276}
277
Roshan Pius735ff432017-07-25 08:48:08 -0700278legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy(
279 V1_1::IWifiChip::TxPowerScenario hidl_scenario) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700280 switch (hidl_scenario) {
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800281 // This is the only supported scenario for V1_1
Jong Wook Kimda830c92018-07-23 15:29:38 -0700282 case V1_1::IWifiChip::TxPowerScenario::VOICE_CALL:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700283 return legacy_hal::WIFI_POWER_SCENARIO_VOICE_CALL;
284 };
285 CHECK(false);
Roshan Pius735ff432017-07-25 08:48:08 -0700286}
287
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800288legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy_1_2(
Jong Wook Kimda830c92018-07-23 15:29:38 -0700289 V1_2::IWifiChip::TxPowerScenario hidl_scenario) {
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800290 switch (hidl_scenario) {
291 // This is the only supported scenario for V1_1
Jong Wook Kimda830c92018-07-23 15:29:38 -0700292 case V1_2::IWifiChip::TxPowerScenario::VOICE_CALL:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800293 return legacy_hal::WIFI_POWER_SCENARIO_VOICE_CALL;
294 // Those are the supported scenarios for V1_2
Jong Wook Kimda830c92018-07-23 15:29:38 -0700295 case V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800296 return legacy_hal::WIFI_POWER_SCENARIO_ON_HEAD_CELL_OFF;
Jong Wook Kimda830c92018-07-23 15:29:38 -0700297 case V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_ON:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800298 return legacy_hal::WIFI_POWER_SCENARIO_ON_HEAD_CELL_ON;
Jong Wook Kimda830c92018-07-23 15:29:38 -0700299 case V1_2::IWifiChip::TxPowerScenario::ON_BODY_CELL_OFF:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800300 return legacy_hal::WIFI_POWER_SCENARIO_ON_BODY_CELL_OFF;
Jong Wook Kimda830c92018-07-23 15:29:38 -0700301 case V1_2::IWifiChip::TxPowerScenario::ON_BODY_CELL_ON:
Ahmed ElArabawy6a1accf2018-01-23 10:57:29 -0800302 return legacy_hal::WIFI_POWER_SCENARIO_ON_BODY_CELL_ON;
303 };
304 CHECK(false);
305}
306
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700307legacy_hal::wifi_latency_mode convertHidlLatencyModeToLegacy(
Ahmed ElArabawyf501a982019-07-23 15:02:22 -0700308 V1_3::IWifiChip::LatencyMode hidl_latency_mode) {
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700309 switch (hidl_latency_mode) {
Ahmed ElArabawyf501a982019-07-23 15:02:22 -0700310 case V1_3::IWifiChip::LatencyMode::NORMAL:
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700311 return legacy_hal::WIFI_LATENCY_MODE_NORMAL;
Ahmed ElArabawyf501a982019-07-23 15:02:22 -0700312 case V1_3::IWifiChip::LatencyMode::LOW:
Ahmed ElArabawyeaf82402018-10-26 09:46:04 -0700313 return legacy_hal::WIFI_LATENCY_MODE_LOW;
314 }
315 CHECK(false);
316}
317
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800318bool convertLegacyWifiMacInfoToHidl(
319 const legacy_hal::WifiMacInfo& legacy_mac_info,
Jimmy Chend460df32019-11-29 17:31:22 +0200320 V1_4::IWifiChipEventCallback::RadioModeInfo* hidl_radio_mode_info) {
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800321 if (!hidl_radio_mode_info) {
322 return false;
323 }
324 *hidl_radio_mode_info = {};
325
326 hidl_radio_mode_info->radioId = legacy_mac_info.wlan_mac_id;
327 // Convert from bitmask of bands in the legacy HAL to enum value in
328 // the HIDL interface.
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800329 if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND &&
330 legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND &&
331 legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND) {
Jimmy Chend460df32019-11-29 17:31:22 +0200332 hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_24GHZ_5GHZ_6GHZ;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800333 } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND &&
334 legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
Jimmy Chend460df32019-11-29 17:31:22 +0200335 hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_5GHZ_6GHZ;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800336 } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND) {
Jimmy Chend460df32019-11-29 17:31:22 +0200337 hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_6GHZ;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800338 } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND &&
339 legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
Jimmy Chend460df32019-11-29 17:31:22 +0200340 hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_24GHZ_5GHZ;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800341 } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND) {
Jimmy Chend460df32019-11-29 17:31:22 +0200342 hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_24GHZ;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800343 } else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
Jimmy Chend460df32019-11-29 17:31:22 +0200344 hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_5GHZ;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800345 } else {
Jimmy Chend460df32019-11-29 17:31:22 +0200346 hidl_radio_mode_info->bandInfo = V1_4::WifiBand::BAND_UNSPECIFIED;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800347 }
Jong Wook Kimda830c92018-07-23 15:29:38 -0700348 std::vector<V1_2::IWifiChipEventCallback::IfaceInfo> iface_info_vec;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800349 for (const auto& legacy_iface_info : legacy_mac_info.iface_infos) {
Jong Wook Kimda830c92018-07-23 15:29:38 -0700350 V1_2::IWifiChipEventCallback::IfaceInfo iface_info;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800351 iface_info.name = legacy_iface_info.name;
352 iface_info.channel = legacy_iface_info.channel;
353 iface_info_vec.push_back(iface_info);
354 }
355 hidl_radio_mode_info->ifaceInfos = iface_info_vec;
356 return true;
357}
358
359bool convertLegacyWifiMacInfosToHidl(
360 const std::vector<legacy_hal::WifiMacInfo>& legacy_mac_infos,
Jimmy Chend460df32019-11-29 17:31:22 +0200361 std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo>*
362 hidl_radio_mode_infos) {
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800363 if (!hidl_radio_mode_infos) {
364 return false;
365 }
366 *hidl_radio_mode_infos = {};
367
368 for (const auto& legacy_mac_info : legacy_mac_infos) {
Jimmy Chend460df32019-11-29 17:31:22 +0200369 V1_4::IWifiChipEventCallback::RadioModeInfo hidl_radio_mode_info;
Roshan Pius1a7b1db2018-01-22 17:57:20 -0800370 if (!convertLegacyWifiMacInfoToHidl(legacy_mac_info,
371 &hidl_radio_mode_info)) {
372 return false;
373 }
374 hidl_radio_mode_infos->push_back(hidl_radio_mode_info);
375 }
376 return true;
377}
378
Roshan Piusf72df2e2016-12-04 10:49:38 -0800379bool convertLegacyFeaturesToHidlStaCapabilities(
Ahmed ElArabawy95e36b72019-11-15 21:24:53 +0000380 uint64_t legacy_feature_set, uint32_t legacy_logger_feature_set,
Roshan Piusf72df2e2016-12-04 10:49:38 -0800381 uint32_t* hidl_caps) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700382 if (!hidl_caps) {
383 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800384 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700385 *hidl_caps = {};
386 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask;
387 for (const auto feature : {legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED}) {
388 if (feature & legacy_logger_feature_set) {
389 *hidl_caps |=
390 convertLegacyLoggerFeatureToHidlStaIfaceCapability(feature);
391 }
Roshan Piusf72df2e2016-12-04 10:49:38 -0800392 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700393 for (const auto feature :
394 {WIFI_FEATURE_GSCAN, WIFI_FEATURE_LINK_LAYER_STATS,
395 WIFI_FEATURE_RSSI_MONITOR, WIFI_FEATURE_CONTROL_ROAMING,
396 WIFI_FEATURE_IE_WHITELIST, WIFI_FEATURE_SCAN_RAND,
397 WIFI_FEATURE_INFRA_5G, WIFI_FEATURE_HOTSPOT, WIFI_FEATURE_PNO,
398 WIFI_FEATURE_TDLS, WIFI_FEATURE_TDLS_OFFCHANNEL,
Ahmed ElArabawyb23485d2019-12-09 15:24:16 -0800399 WIFI_FEATURE_CONFIG_NDO, WIFI_FEATURE_MKEEP_ALIVE}) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700400 if (feature & legacy_feature_set) {
401 *hidl_caps |= convertLegacyFeatureToHidlStaIfaceCapability(feature);
402 }
403 }
404 // There is no flag for this one in the legacy feature set. Adding it to the
405 // set because all the current devices support it.
406 *hidl_caps |= HidlStaIfaceCaps::APF;
407 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800408}
409
410bool convertLegacyApfCapabilitiesToHidl(
411 const legacy_hal::PacketFilterCapabilities& legacy_caps,
412 StaApfPacketFilterCapabilities* hidl_caps) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700413 if (!hidl_caps) {
414 return false;
415 }
416 *hidl_caps = {};
417 hidl_caps->version = legacy_caps.version;
418 hidl_caps->maxLength = legacy_caps.max_len;
419 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800420}
421
Roshan Pius881d1f72016-12-05 15:37:00 -0800422uint8_t convertHidlGscanReportEventFlagToLegacy(
423 StaBackgroundScanBucketEventReportSchemeMask hidl_flag) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700424 using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
425 switch (hidl_flag) {
426 case HidlFlag::EACH_SCAN:
427 return REPORT_EVENTS_EACH_SCAN;
428 case HidlFlag::FULL_RESULTS:
429 return REPORT_EVENTS_FULL_RESULTS;
430 case HidlFlag::NO_BATCH:
431 return REPORT_EVENTS_NO_BATCH;
432 };
433 CHECK(false);
Roshan Pius881d1f72016-12-05 15:37:00 -0800434}
435
436StaScanDataFlagMask convertLegacyGscanDataFlagToHidl(uint8_t legacy_flag) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700437 switch (legacy_flag) {
438 case legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED:
439 return StaScanDataFlagMask::INTERRUPTED;
440 };
441 CHECK(false) << "Unknown legacy flag: " << legacy_flag;
442 // To silence the compiler warning about reaching the end of non-void
443 // function.
444 return {};
Roshan Pius881d1f72016-12-05 15:37:00 -0800445}
446
447bool convertLegacyGscanCapabilitiesToHidl(
Roshan Piusf72df2e2016-12-04 10:49:38 -0800448 const legacy_hal::wifi_gscan_capabilities& legacy_caps,
449 StaBackgroundScanCapabilities* hidl_caps) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700450 if (!hidl_caps) {
451 return false;
452 }
453 *hidl_caps = {};
454 hidl_caps->maxCacheSize = legacy_caps.max_scan_cache_size;
455 hidl_caps->maxBuckets = legacy_caps.max_scan_buckets;
456 hidl_caps->maxApCachePerScan = legacy_caps.max_ap_cache_per_scan;
457 hidl_caps->maxReportingThreshold = legacy_caps.max_scan_reporting_threshold;
458 return true;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800459}
460
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800461legacy_hal::wifi_band convertHidlWifiBandToLegacy(V1_0::WifiBand band) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700462 switch (band) {
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800463 case V1_0::WifiBand::BAND_UNSPECIFIED:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700464 return legacy_hal::WIFI_BAND_UNSPECIFIED;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800465 case V1_0::WifiBand::BAND_24GHZ:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700466 return legacy_hal::WIFI_BAND_BG;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800467 case V1_0::WifiBand::BAND_5GHZ:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700468 return legacy_hal::WIFI_BAND_A;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800469 case V1_0::WifiBand::BAND_5GHZ_DFS:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700470 return legacy_hal::WIFI_BAND_A_DFS;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800471 case V1_0::WifiBand::BAND_5GHZ_WITH_DFS:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700472 return legacy_hal::WIFI_BAND_A_WITH_DFS;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800473 case V1_0::WifiBand::BAND_24GHZ_5GHZ:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700474 return legacy_hal::WIFI_BAND_ABG;
Ahmed ElArabawyfd809fc2019-11-15 18:19:15 -0800475 case V1_0::WifiBand::BAND_24GHZ_5GHZ_WITH_DFS:
Roshan Piusabcf78f2017-10-06 16:30:38 -0700476 return legacy_hal::WIFI_BAND_ABG_WITH_DFS;
477 };
478 CHECK(false);
Roshan Pius881d1f72016-12-05 15:37:00 -0800479}
480
481bool convertHidlGscanParamsToLegacy(
Roshan Piuse65edb12016-11-22 13:02:01 -0800482 const StaBackgroundScanParameters& hidl_scan_params,
483 legacy_hal::wifi_scan_cmd_params* legacy_scan_params) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700484 if (!legacy_scan_params) {
485 return false;
Roshan Pius4cf40592017-03-07 11:17:08 -0800486 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700487 *legacy_scan_params = {};
488 legacy_scan_params->base_period = hidl_scan_params.basePeriodInMs;
489 legacy_scan_params->max_ap_per_scan = hidl_scan_params.maxApPerScan;
490 legacy_scan_params->report_threshold_percent =
491 hidl_scan_params.reportThresholdPercent;
492 legacy_scan_params->report_threshold_num_scans =
493 hidl_scan_params.reportThresholdNumScans;
494 if (hidl_scan_params.buckets.size() > MAX_BUCKETS) {
495 return false;
Roshan Piuse65edb12016-11-22 13:02:01 -0800496 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700497 legacy_scan_params->num_buckets = hidl_scan_params.buckets.size();
498 for (uint32_t bucket_idx = 0; bucket_idx < hidl_scan_params.buckets.size();
499 bucket_idx++) {
500 const StaBackgroundScanBucketParameters& hidl_bucket_spec =
501 hidl_scan_params.buckets[bucket_idx];
502 legacy_hal::wifi_scan_bucket_spec& legacy_bucket_spec =
503 legacy_scan_params->buckets[bucket_idx];
504 if (hidl_bucket_spec.bucketIdx >= MAX_BUCKETS) {
505 return false;
506 }
507 legacy_bucket_spec.bucket = hidl_bucket_spec.bucketIdx;
508 legacy_bucket_spec.band =
509 convertHidlWifiBandToLegacy(hidl_bucket_spec.band);
510 legacy_bucket_spec.period = hidl_bucket_spec.periodInMs;
511 legacy_bucket_spec.max_period =
512 hidl_bucket_spec.exponentialMaxPeriodInMs;
513 legacy_bucket_spec.base = hidl_bucket_spec.exponentialBase;
514 legacy_bucket_spec.step_count = hidl_bucket_spec.exponentialStepCount;
515 legacy_bucket_spec.report_events = 0;
516 using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
517 for (const auto flag : {HidlFlag::EACH_SCAN, HidlFlag::FULL_RESULTS,
518 HidlFlag::NO_BATCH}) {
519 if (hidl_bucket_spec.eventReportScheme &
520 static_cast<std::underlying_type<HidlFlag>::type>(flag)) {
521 legacy_bucket_spec.report_events |=
522 convertHidlGscanReportEventFlagToLegacy(flag);
523 }
524 }
525 if (hidl_bucket_spec.frequencies.size() > MAX_CHANNELS) {
526 return false;
527 }
528 legacy_bucket_spec.num_channels = hidl_bucket_spec.frequencies.size();
529 for (uint32_t freq_idx = 0;
530 freq_idx < hidl_bucket_spec.frequencies.size(); freq_idx++) {
531 legacy_bucket_spec.channels[freq_idx].channel =
532 hidl_bucket_spec.frequencies[freq_idx];
533 }
Roshan Piuse65edb12016-11-22 13:02:01 -0800534 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700535 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800536}
537
Roshan Pius3fae9c82016-12-02 14:49:41 -0800538bool convertLegacyIeToHidl(
539 const legacy_hal::wifi_information_element& legacy_ie,
540 WifiInformationElement* hidl_ie) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700541 if (!hidl_ie) {
542 return false;
543 }
544 *hidl_ie = {};
545 hidl_ie->id = legacy_ie.id;
546 hidl_ie->data =
547 std::vector<uint8_t>(legacy_ie.data, legacy_ie.data + legacy_ie.len);
548 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -0800549}
550
Roshan Piusabcf78f2017-10-06 16:30:38 -0700551bool convertLegacyIeBlobToHidl(const uint8_t* ie_blob, uint32_t ie_blob_len,
Roshan Piuse65edb12016-11-22 13:02:01 -0800552 std::vector<WifiInformationElement>* hidl_ies) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700553 if (!ie_blob || !hidl_ies) {
554 return false;
Roshan Piuse65edb12016-11-22 13:02:01 -0800555 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700556 *hidl_ies = {};
557 const uint8_t* ies_begin = ie_blob;
558 const uint8_t* ies_end = ie_blob + ie_blob_len;
559 const uint8_t* next_ie = ies_begin;
560 using wifi_ie = legacy_hal::wifi_information_element;
561 constexpr size_t kIeHeaderLen = sizeof(wifi_ie);
562 // Each IE should atleast have the header (i.e |id| & |len| fields).
563 while (next_ie + kIeHeaderLen <= ies_end) {
564 const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie));
565 uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len;
566 if (next_ie + curr_ie_len > ies_end) {
567 LOG(ERROR) << "Error parsing IE blob. Next IE: " << (void*)next_ie
568 << ", Curr IE len: " << curr_ie_len
569 << ", IEs End: " << (void*)ies_end;
570 break;
571 }
572 WifiInformationElement hidl_ie;
573 if (!convertLegacyIeToHidl(legacy_ie, &hidl_ie)) {
574 LOG(ERROR) << "Error converting IE. Id: " << legacy_ie.id
575 << ", len: " << legacy_ie.len;
576 break;
577 }
578 hidl_ies->push_back(std::move(hidl_ie));
579 next_ie += curr_ie_len;
Roshan Pius3fae9c82016-12-02 14:49:41 -0800580 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700581 // Check if the blob has been fully consumed.
582 if (next_ie != ies_end) {
583 LOG(ERROR) << "Failed to fully parse IE blob. Next IE: "
584 << (void*)next_ie << ", IEs End: " << (void*)ies_end;
585 }
586 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800587}
588
Roshan Pius881d1f72016-12-05 15:37:00 -0800589bool convertLegacyGscanResultToHidl(
Roshan Piusabcf78f2017-10-06 16:30:38 -0700590 const legacy_hal::wifi_scan_result& legacy_scan_result, bool has_ie_data,
Roshan Piuse65edb12016-11-22 13:02:01 -0800591 StaScanResult* hidl_scan_result) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700592 if (!hidl_scan_result) {
593 return false;
Roshan Piuse65edb12016-11-22 13:02:01 -0800594 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700595 *hidl_scan_result = {};
596 hidl_scan_result->timeStampInUs = legacy_scan_result.ts;
597 hidl_scan_result->ssid = std::vector<uint8_t>(
598 legacy_scan_result.ssid,
599 legacy_scan_result.ssid + strnlen(legacy_scan_result.ssid,
600 sizeof(legacy_scan_result.ssid) - 1));
601 memcpy(hidl_scan_result->bssid.data(), legacy_scan_result.bssid,
602 hidl_scan_result->bssid.size());
603 hidl_scan_result->frequency = legacy_scan_result.channel;
604 hidl_scan_result->rssi = legacy_scan_result.rssi;
605 hidl_scan_result->beaconPeriodInMs = legacy_scan_result.beacon_period;
606 hidl_scan_result->capability = legacy_scan_result.capability;
607 if (has_ie_data) {
608 std::vector<WifiInformationElement> ies;
609 if (!convertLegacyIeBlobToHidl(
610 reinterpret_cast<const uint8_t*>(legacy_scan_result.ie_data),
611 legacy_scan_result.ie_length, &ies)) {
612 return false;
613 }
614 hidl_scan_result->informationElements = std::move(ies);
615 }
616 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800617}
618
Roshan Pius881d1f72016-12-05 15:37:00 -0800619bool convertLegacyCachedGscanResultsToHidl(
Roshan Piuse65edb12016-11-22 13:02:01 -0800620 const legacy_hal::wifi_cached_scan_results& legacy_cached_scan_result,
621 StaScanData* hidl_scan_data) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700622 if (!hidl_scan_data) {
623 return false;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800624 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700625 *hidl_scan_data = {};
626 hidl_scan_data->flags = 0;
627 for (const auto flag : {legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED}) {
628 if (legacy_cached_scan_result.flags & flag) {
629 hidl_scan_data->flags |=
630 static_cast<std::underlying_type<StaScanDataFlagMask>::type>(
631 convertLegacyGscanDataFlagToHidl(flag));
632 }
633 }
634 hidl_scan_data->bucketsScanned = legacy_cached_scan_result.buckets_scanned;
Roshan Piuse65edb12016-11-22 13:02:01 -0800635
Roshan Piusabcf78f2017-10-06 16:30:38 -0700636 CHECK(legacy_cached_scan_result.num_results >= 0 &&
637 legacy_cached_scan_result.num_results <= MAX_AP_CACHE_PER_SCAN);
638 std::vector<StaScanResult> hidl_scan_results;
639 for (int32_t result_idx = 0;
640 result_idx < legacy_cached_scan_result.num_results; result_idx++) {
641 StaScanResult hidl_scan_result;
642 if (!convertLegacyGscanResultToHidl(
643 legacy_cached_scan_result.results[result_idx], false,
644 &hidl_scan_result)) {
645 return false;
646 }
647 hidl_scan_results.push_back(hidl_scan_result);
Roshan Piuse65edb12016-11-22 13:02:01 -0800648 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700649 hidl_scan_data->results = std::move(hidl_scan_results);
650 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800651}
652
Roshan Pius881d1f72016-12-05 15:37:00 -0800653bool convertLegacyVectorOfCachedGscanResultsToHidl(
Roshan Piuse65edb12016-11-22 13:02:01 -0800654 const std::vector<legacy_hal::wifi_cached_scan_results>&
655 legacy_cached_scan_results,
656 std::vector<StaScanData>* hidl_scan_datas) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700657 if (!hidl_scan_datas) {
658 return false;
Roshan Piuse65edb12016-11-22 13:02:01 -0800659 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700660 *hidl_scan_datas = {};
661 for (const auto& legacy_cached_scan_result : legacy_cached_scan_results) {
662 StaScanData hidl_scan_data;
663 if (!convertLegacyCachedGscanResultsToHidl(legacy_cached_scan_result,
664 &hidl_scan_data)) {
665 return false;
666 }
667 hidl_scan_datas->push_back(hidl_scan_data);
668 }
669 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800670}
671
Roshan Pius32d0ca92016-12-02 11:21:19 -0800672WifiDebugTxPacketFate convertLegacyDebugTxPacketFateToHidl(
673 legacy_hal::wifi_tx_packet_fate fate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700674 switch (fate) {
675 case legacy_hal::TX_PKT_FATE_ACKED:
676 return WifiDebugTxPacketFate::ACKED;
677 case legacy_hal::TX_PKT_FATE_SENT:
678 return WifiDebugTxPacketFate::SENT;
679 case legacy_hal::TX_PKT_FATE_FW_QUEUED:
680 return WifiDebugTxPacketFate::FW_QUEUED;
681 case legacy_hal::TX_PKT_FATE_FW_DROP_INVALID:
682 return WifiDebugTxPacketFate::FW_DROP_INVALID;
683 case legacy_hal::TX_PKT_FATE_FW_DROP_NOBUFS:
684 return WifiDebugTxPacketFate::FW_DROP_NOBUFS;
685 case legacy_hal::TX_PKT_FATE_FW_DROP_OTHER:
686 return WifiDebugTxPacketFate::FW_DROP_OTHER;
687 case legacy_hal::TX_PKT_FATE_DRV_QUEUED:
688 return WifiDebugTxPacketFate::DRV_QUEUED;
689 case legacy_hal::TX_PKT_FATE_DRV_DROP_INVALID:
690 return WifiDebugTxPacketFate::DRV_DROP_INVALID;
691 case legacy_hal::TX_PKT_FATE_DRV_DROP_NOBUFS:
692 return WifiDebugTxPacketFate::DRV_DROP_NOBUFS;
693 case legacy_hal::TX_PKT_FATE_DRV_DROP_OTHER:
694 return WifiDebugTxPacketFate::DRV_DROP_OTHER;
695 };
696 CHECK(false) << "Unknown legacy fate type: " << fate;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800697}
698
699WifiDebugRxPacketFate convertLegacyDebugRxPacketFateToHidl(
700 legacy_hal::wifi_rx_packet_fate fate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700701 switch (fate) {
702 case legacy_hal::RX_PKT_FATE_SUCCESS:
703 return WifiDebugRxPacketFate::SUCCESS;
704 case legacy_hal::RX_PKT_FATE_FW_QUEUED:
705 return WifiDebugRxPacketFate::FW_QUEUED;
706 case legacy_hal::RX_PKT_FATE_FW_DROP_FILTER:
707 return WifiDebugRxPacketFate::FW_DROP_FILTER;
708 case legacy_hal::RX_PKT_FATE_FW_DROP_INVALID:
709 return WifiDebugRxPacketFate::FW_DROP_INVALID;
710 case legacy_hal::RX_PKT_FATE_FW_DROP_NOBUFS:
711 return WifiDebugRxPacketFate::FW_DROP_NOBUFS;
712 case legacy_hal::RX_PKT_FATE_FW_DROP_OTHER:
713 return WifiDebugRxPacketFate::FW_DROP_OTHER;
714 case legacy_hal::RX_PKT_FATE_DRV_QUEUED:
715 return WifiDebugRxPacketFate::DRV_QUEUED;
716 case legacy_hal::RX_PKT_FATE_DRV_DROP_FILTER:
717 return WifiDebugRxPacketFate::DRV_DROP_FILTER;
718 case legacy_hal::RX_PKT_FATE_DRV_DROP_INVALID:
719 return WifiDebugRxPacketFate::DRV_DROP_INVALID;
720 case legacy_hal::RX_PKT_FATE_DRV_DROP_NOBUFS:
721 return WifiDebugRxPacketFate::DRV_DROP_NOBUFS;
722 case legacy_hal::RX_PKT_FATE_DRV_DROP_OTHER:
723 return WifiDebugRxPacketFate::DRV_DROP_OTHER;
724 };
725 CHECK(false) << "Unknown legacy fate type: " << fate;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800726}
727
728WifiDebugPacketFateFrameType convertLegacyDebugPacketFateFrameTypeToHidl(
729 legacy_hal::frame_type type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700730 switch (type) {
731 case legacy_hal::FRAME_TYPE_UNKNOWN:
732 return WifiDebugPacketFateFrameType::UNKNOWN;
733 case legacy_hal::FRAME_TYPE_ETHERNET_II:
734 return WifiDebugPacketFateFrameType::ETHERNET_II;
735 case legacy_hal::FRAME_TYPE_80211_MGMT:
736 return WifiDebugPacketFateFrameType::MGMT_80211;
737 };
738 CHECK(false) << "Unknown legacy frame type: " << type;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800739}
740
741bool convertLegacyDebugPacketFateFrameToHidl(
742 const legacy_hal::frame_info& legacy_frame,
743 WifiDebugPacketFateFrameInfo* hidl_frame) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700744 if (!hidl_frame) {
745 return false;
746 }
747 *hidl_frame = {};
748 hidl_frame->frameType =
749 convertLegacyDebugPacketFateFrameTypeToHidl(legacy_frame.payload_type);
750 hidl_frame->frameLen = legacy_frame.frame_len;
751 hidl_frame->driverTimestampUsec = legacy_frame.driver_timestamp_usec;
752 hidl_frame->firmwareTimestampUsec = legacy_frame.firmware_timestamp_usec;
753 const uint8_t* frame_begin = reinterpret_cast<const uint8_t*>(
754 legacy_frame.frame_content.ethernet_ii_bytes);
755 hidl_frame->frameContent =
756 std::vector<uint8_t>(frame_begin, frame_begin + legacy_frame.frame_len);
757 return true;
Roshan Pius32d0ca92016-12-02 11:21:19 -0800758}
759
760bool convertLegacyDebugTxPacketFateToHidl(
761 const legacy_hal::wifi_tx_report& legacy_fate,
762 WifiDebugTxPacketFateReport* hidl_fate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700763 if (!hidl_fate) {
764 return false;
765 }
766 *hidl_fate = {};
767 hidl_fate->fate = convertLegacyDebugTxPacketFateToHidl(legacy_fate.fate);
768 return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
769 &hidl_fate->frameInfo);
Roshan Pius32d0ca92016-12-02 11:21:19 -0800770}
771
Roshan Piusf72df2e2016-12-04 10:49:38 -0800772bool convertLegacyVectorOfDebugTxPacketFateToHidl(
773 const std::vector<legacy_hal::wifi_tx_report>& legacy_fates,
774 std::vector<WifiDebugTxPacketFateReport>* hidl_fates) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700775 if (!hidl_fates) {
776 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800777 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700778 *hidl_fates = {};
779 for (const auto& legacy_fate : legacy_fates) {
780 WifiDebugTxPacketFateReport hidl_fate;
781 if (!convertLegacyDebugTxPacketFateToHidl(legacy_fate, &hidl_fate)) {
782 return false;
783 }
784 hidl_fates->push_back(hidl_fate);
785 }
786 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800787}
788
Roshan Pius32d0ca92016-12-02 11:21:19 -0800789bool convertLegacyDebugRxPacketFateToHidl(
790 const legacy_hal::wifi_rx_report& legacy_fate,
791 WifiDebugRxPacketFateReport* hidl_fate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700792 if (!hidl_fate) {
793 return false;
794 }
795 *hidl_fate = {};
796 hidl_fate->fate = convertLegacyDebugRxPacketFateToHidl(legacy_fate.fate);
797 return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
798 &hidl_fate->frameInfo);
Roshan Pius32d0ca92016-12-02 11:21:19 -0800799}
800
Roshan Piusf72df2e2016-12-04 10:49:38 -0800801bool convertLegacyVectorOfDebugRxPacketFateToHidl(
802 const std::vector<legacy_hal::wifi_rx_report>& legacy_fates,
803 std::vector<WifiDebugRxPacketFateReport>* hidl_fates) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700804 if (!hidl_fates) {
805 return false;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800806 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700807 *hidl_fates = {};
808 for (const auto& legacy_fate : legacy_fates) {
809 WifiDebugRxPacketFateReport hidl_fate;
810 if (!convertLegacyDebugRxPacketFateToHidl(legacy_fate, &hidl_fate)) {
811 return false;
812 }
813 hidl_fates->push_back(hidl_fate);
814 }
815 return true;
Roshan Piusf72df2e2016-12-04 10:49:38 -0800816}
817
Sunil Ravib0343e72018-11-13 15:52:00 -0800818bool convertLegacyLinkLayerRadioStatsToHidl(
819 const legacy_hal::LinkLayerRadioStats& legacy_radio_stat,
820 V1_3::StaLinkLayerRadioStats* hidl_radio_stat) {
821 if (!hidl_radio_stat) {
822 return false;
823 }
824 *hidl_radio_stat = {};
825
826 hidl_radio_stat->V1_0.onTimeInMs = legacy_radio_stat.stats.on_time;
827 hidl_radio_stat->V1_0.txTimeInMs = legacy_radio_stat.stats.tx_time;
828 hidl_radio_stat->V1_0.rxTimeInMs = legacy_radio_stat.stats.rx_time;
829 hidl_radio_stat->V1_0.onTimeInMsForScan =
830 legacy_radio_stat.stats.on_time_scan;
831 hidl_radio_stat->V1_0.txTimeInMsPerLevel =
832 legacy_radio_stat.tx_time_per_levels;
833 hidl_radio_stat->onTimeInMsForNanScan = legacy_radio_stat.stats.on_time_nbd;
834 hidl_radio_stat->onTimeInMsForBgScan =
835 legacy_radio_stat.stats.on_time_gscan;
836 hidl_radio_stat->onTimeInMsForRoamScan =
837 legacy_radio_stat.stats.on_time_roam_scan;
838 hidl_radio_stat->onTimeInMsForPnoScan =
839 legacy_radio_stat.stats.on_time_pno_scan;
840 hidl_radio_stat->onTimeInMsForHs20Scan =
841 legacy_radio_stat.stats.on_time_hs20;
842
843 std::vector<V1_3::WifiChannelStats> hidl_channel_stats;
844
845 for (const auto& channel_stat : legacy_radio_stat.channel_stats) {
846 V1_3::WifiChannelStats hidl_channel_stat;
847 hidl_channel_stat.onTimeInMs = channel_stat.on_time;
848 hidl_channel_stat.ccaBusyTimeInMs = channel_stat.cca_busy_time;
849 /*
850 * TODO once b/119142899 is fixed,
851 * replace below code with convertLegacyWifiChannelInfoToHidl()
852 */
853 hidl_channel_stat.channel.width = WifiChannelWidthInMhz::WIDTH_20;
854 hidl_channel_stat.channel.centerFreq = channel_stat.channel.center_freq;
855 hidl_channel_stat.channel.centerFreq0 =
856 channel_stat.channel.center_freq0;
857 hidl_channel_stat.channel.centerFreq1 =
858 channel_stat.channel.center_freq1;
859 hidl_channel_stats.push_back(hidl_channel_stat);
860 }
861
862 hidl_radio_stat->channelStats = hidl_channel_stats;
863
864 return true;
865}
866
Roshan Piuse65edb12016-11-22 13:02:01 -0800867bool convertLegacyLinkLayerStatsToHidl(
868 const legacy_hal::LinkLayerStats& legacy_stats,
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800869 StaLinkLayerStats* hidl_stats) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700870 if (!hidl_stats) {
871 return false;
872 }
873 *hidl_stats = {};
874 // iface legacy_stats conversion.
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800875 hidl_stats->iface.V1_0.beaconRx = legacy_stats.iface.beacon_rx;
876 hidl_stats->iface.V1_0.avgRssiMgmt = legacy_stats.iface.rssi_mgmt;
877 hidl_stats->iface.V1_0.wmeBePktStats.rxMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700878 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800879 hidl_stats->iface.V1_0.wmeBePktStats.txMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700880 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800881 hidl_stats->iface.V1_0.wmeBePktStats.lostMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700882 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800883 hidl_stats->iface.V1_0.wmeBePktStats.retries =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700884 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800885 hidl_stats->iface.V1_0.wmeBkPktStats.rxMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700886 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800887 hidl_stats->iface.V1_0.wmeBkPktStats.txMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700888 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800889 hidl_stats->iface.V1_0.wmeBkPktStats.lostMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700890 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800891 hidl_stats->iface.V1_0.wmeBkPktStats.retries =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700892 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800893 hidl_stats->iface.V1_0.wmeViPktStats.rxMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700894 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800895 hidl_stats->iface.V1_0.wmeViPktStats.txMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700896 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800897 hidl_stats->iface.V1_0.wmeViPktStats.lostMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700898 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800899 hidl_stats->iface.V1_0.wmeViPktStats.retries =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700900 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800901 hidl_stats->iface.V1_0.wmeVoPktStats.rxMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700902 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800903 hidl_stats->iface.V1_0.wmeVoPktStats.txMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700904 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800905 hidl_stats->iface.V1_0.wmeVoPktStats.lostMpdu =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700906 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800907 hidl_stats->iface.V1_0.wmeVoPktStats.retries =
Roshan Piusabcf78f2017-10-06 16:30:38 -0700908 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries;
Roshan Piuse9d1e7d2020-11-04 11:44:16 -0800909 hidl_stats->iface.timeSliceDutyCycleInPercent =
910 legacy_stats.iface.info.time_slicing_duty_cycle_percent;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700911 // radio legacy_stats conversion.
xshue9873252018-08-07 11:04:34 -0700912 std::vector<V1_3::StaLinkLayerRadioStats> hidl_radios_stats;
Roshan Piusabcf78f2017-10-06 16:30:38 -0700913 for (const auto& legacy_radio_stats : legacy_stats.radios) {
xshue9873252018-08-07 11:04:34 -0700914 V1_3::StaLinkLayerRadioStats hidl_radio_stats;
Sunil Ravib0343e72018-11-13 15:52:00 -0800915 if (!convertLegacyLinkLayerRadioStatsToHidl(legacy_radio_stats,
916 &hidl_radio_stats)) {
917 return false;
918 }
Roshan Piusabcf78f2017-10-06 16:30:38 -0700919 hidl_radios_stats.push_back(hidl_radio_stats);
920 }
921 hidl_stats->radios = hidl_radios_stats;
922 // Timestamp in the HAL wrapper here since it's not provided in the legacy
923 // HAL API.
924 hidl_stats->timeStampInMs = uptimeMillis();
925 return true;
Roshan Piuse65edb12016-11-22 13:02:01 -0800926}
Roshan Piusf5f51fd2016-12-01 13:54:24 -0800927
Roshan Pius26801cb2016-12-13 14:25:45 -0800928bool convertLegacyRoamingCapabilitiesToHidl(
929 const legacy_hal::wifi_roaming_capabilities& legacy_caps,
930 StaRoamingCapabilities* hidl_caps) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700931 if (!hidl_caps) {
932 return false;
933 }
934 *hidl_caps = {};
935 hidl_caps->maxBlacklistSize = legacy_caps.max_blacklist_size;
936 hidl_caps->maxWhitelistSize = legacy_caps.max_whitelist_size;
937 return true;
Roshan Pius26801cb2016-12-13 14:25:45 -0800938}
939
940bool convertHidlRoamingConfigToLegacy(
941 const StaRoamingConfig& hidl_config,
942 legacy_hal::wifi_roaming_config* legacy_config) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700943 if (!legacy_config) {
944 return false;
945 }
946 *legacy_config = {};
947 if (hidl_config.bssidBlacklist.size() > MAX_BLACKLIST_BSSID ||
948 hidl_config.ssidWhitelist.size() > MAX_WHITELIST_SSID) {
949 return false;
950 }
951 legacy_config->num_blacklist_bssid = hidl_config.bssidBlacklist.size();
952 uint32_t i = 0;
953 for (const auto& bssid : hidl_config.bssidBlacklist) {
954 CHECK(bssid.size() == sizeof(legacy_hal::mac_addr));
955 memcpy(legacy_config->blacklist_bssid[i++], bssid.data(), bssid.size());
956 }
957 legacy_config->num_whitelist_ssid = hidl_config.ssidWhitelist.size();
958 i = 0;
959 for (const auto& ssid : hidl_config.ssidWhitelist) {
960 CHECK(ssid.size() <= sizeof(legacy_hal::ssid_t::ssid_str));
961 legacy_config->whitelist_ssid[i].length = ssid.size();
962 memcpy(legacy_config->whitelist_ssid[i].ssid_str, ssid.data(),
963 ssid.size());
964 i++;
965 }
966 return true;
Roshan Pius26801cb2016-12-13 14:25:45 -0800967}
968
969legacy_hal::fw_roaming_state_t convertHidlRoamingStateToLegacy(
970 StaRoamingState state) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700971 switch (state) {
972 case StaRoamingState::ENABLED:
973 return legacy_hal::ROAMING_ENABLE;
974 case StaRoamingState::DISABLED:
975 return legacy_hal::ROAMING_DISABLE;
976 };
977 CHECK(false);
Roshan Pius26801cb2016-12-13 14:25:45 -0800978}
979
Etan Cohen67d378d2017-04-03 16:10:54 -0700980legacy_hal::NanMatchAlg convertHidlNanMatchAlgToLegacy(NanMatchAlg type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -0700981 switch (type) {
982 case NanMatchAlg::MATCH_ONCE:
983 return legacy_hal::NAN_MATCH_ALG_MATCH_ONCE;
984 case NanMatchAlg::MATCH_CONTINUOUS:
985 return legacy_hal::NAN_MATCH_ALG_MATCH_CONTINUOUS;
986 case NanMatchAlg::MATCH_NEVER:
987 return legacy_hal::NAN_MATCH_ALG_MATCH_NEVER;
988 }
989 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -0700990}
991
Roshan Piusabcf78f2017-10-06 16:30:38 -0700992legacy_hal::NanPublishType convertHidlNanPublishTypeToLegacy(
993 NanPublishType type) {
994 switch (type) {
995 case NanPublishType::UNSOLICITED:
996 return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED;
997 case NanPublishType::SOLICITED:
998 return legacy_hal::NAN_PUBLISH_TYPE_SOLICITED;
999 case NanPublishType::UNSOLICITED_SOLICITED:
1000 return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
1001 }
1002 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001003}
1004
1005legacy_hal::NanTxType convertHidlNanTxTypeToLegacy(NanTxType type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001006 switch (type) {
1007 case NanTxType::BROADCAST:
1008 return legacy_hal::NAN_TX_TYPE_BROADCAST;
1009 case NanTxType::UNICAST:
1010 return legacy_hal::NAN_TX_TYPE_UNICAST;
1011 }
1012 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001013}
1014
Roshan Piusabcf78f2017-10-06 16:30:38 -07001015legacy_hal::NanSubscribeType convertHidlNanSubscribeTypeToLegacy(
1016 NanSubscribeType type) {
1017 switch (type) {
1018 case NanSubscribeType::PASSIVE:
1019 return legacy_hal::NAN_SUBSCRIBE_TYPE_PASSIVE;
1020 case NanSubscribeType::ACTIVE:
1021 return legacy_hal::NAN_SUBSCRIBE_TYPE_ACTIVE;
1022 }
1023 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001024}
1025
1026legacy_hal::NanSRFType convertHidlNanSrfTypeToLegacy(NanSrfType type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001027 switch (type) {
1028 case NanSrfType::BLOOM_FILTER:
1029 return legacy_hal::NAN_SRF_ATTR_BLOOM_FILTER;
1030 case NanSrfType::PARTIAL_MAC_ADDR:
1031 return legacy_hal::NAN_SRF_ATTR_PARTIAL_MAC_ADDR;
1032 }
1033 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001034}
1035
1036legacy_hal::NanDataPathChannelCfg convertHidlNanDataPathChannelCfgToLegacy(
1037 NanDataPathChannelCfg type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001038 switch (type) {
1039 case NanDataPathChannelCfg::CHANNEL_NOT_REQUESTED:
1040 return legacy_hal::NAN_DP_CHANNEL_NOT_REQUESTED;
1041 case NanDataPathChannelCfg::REQUEST_CHANNEL_SETUP:
1042 return legacy_hal::NAN_DP_REQUEST_CHANNEL_SETUP;
1043 case NanDataPathChannelCfg::FORCE_CHANNEL_SETUP:
1044 return legacy_hal::NAN_DP_FORCE_CHANNEL_SETUP;
1045 }
1046 CHECK(false);
Etan Cohen67d378d2017-04-03 16:10:54 -07001047}
1048
Roshan Piusabcf78f2017-10-06 16:30:38 -07001049NanStatusType convertLegacyNanStatusTypeToHidl(legacy_hal::NanStatusType type) {
1050 switch (type) {
1051 case legacy_hal::NAN_STATUS_SUCCESS:
1052 return NanStatusType::SUCCESS;
1053 case legacy_hal::NAN_STATUS_INTERNAL_FAILURE:
1054 return NanStatusType::INTERNAL_FAILURE;
1055 case legacy_hal::NAN_STATUS_PROTOCOL_FAILURE:
1056 return NanStatusType::PROTOCOL_FAILURE;
1057 case legacy_hal::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID:
1058 return NanStatusType::INVALID_SESSION_ID;
1059 case legacy_hal::NAN_STATUS_NO_RESOURCE_AVAILABLE:
1060 return NanStatusType::NO_RESOURCES_AVAILABLE;
1061 case legacy_hal::NAN_STATUS_INVALID_PARAM:
1062 return NanStatusType::INVALID_ARGS;
1063 case legacy_hal::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID:
1064 return NanStatusType::INVALID_PEER_ID;
1065 case legacy_hal::NAN_STATUS_INVALID_NDP_ID:
1066 return NanStatusType::INVALID_NDP_ID;
1067 case legacy_hal::NAN_STATUS_NAN_NOT_ALLOWED:
1068 return NanStatusType::NAN_NOT_ALLOWED;
1069 case legacy_hal::NAN_STATUS_NO_OTA_ACK:
1070 return NanStatusType::NO_OTA_ACK;
1071 case legacy_hal::NAN_STATUS_ALREADY_ENABLED:
1072 return NanStatusType::ALREADY_ENABLED;
1073 case legacy_hal::NAN_STATUS_FOLLOWUP_QUEUE_FULL:
1074 return NanStatusType::FOLLOWUP_TX_QUEUE_FULL;
1075 case legacy_hal::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED:
1076 return NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED;
1077 }
1078 CHECK(false);
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001079}
1080
Roshan Piusabcf78f2017-10-06 16:30:38 -07001081void convertToWifiNanStatus(legacy_hal::NanStatusType type, const char* str,
1082 size_t max_len, WifiNanStatus* wifiNanStatus) {
1083 wifiNanStatus->status = convertLegacyNanStatusTypeToHidl(type);
1084 wifiNanStatus->description = safeConvertChar(str, max_len);
Etan Cohenbbc0f092017-04-26 16:52:34 -07001085}
1086
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001087bool convertHidlNanEnableRequestToLegacy(
Jimmy Chend460df32019-11-29 17:31:22 +02001088 const V1_4::NanEnableRequest& hidl_request,
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001089 legacy_hal::NanEnableRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001090 if (!legacy_request) {
1091 LOG(ERROR)
1092 << "convertHidlNanEnableRequestToLegacy: null legacy_request";
1093 return false;
1094 }
1095 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001096
Roshan Piusabcf78f2017-10-06 16:30:38 -07001097 legacy_request->config_2dot4g_support = 1;
1098 legacy_request->support_2dot4g_val =
1099 hidl_request.operateInBand[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1100 legacy_request->config_support_5g = 1;
1101 legacy_request->support_5g_val =
1102 hidl_request.operateInBand[(size_t)NanBandIndex::NAN_BAND_5GHZ];
1103 legacy_request->config_hop_count_limit = 1;
1104 legacy_request->hop_count_limit_val = hidl_request.hopCountMax;
1105 legacy_request->master_pref = hidl_request.configParams.masterPref;
1106 legacy_request->discovery_indication_cfg = 0;
1107 legacy_request->discovery_indication_cfg |=
1108 hidl_request.configParams.disableDiscoveryAddressChangeIndication ? 0x1
1109 : 0x0;
1110 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001111 hidl_request.configParams.disableStartedClusterIndication ? 0x2 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001112 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001113 hidl_request.configParams.disableJoinedClusterIndication ? 0x4 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001114 legacy_request->config_sid_beacon = 1;
1115 if (hidl_request.configParams.numberOfPublishServiceIdsInBeacon > 127) {
1116 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
1117 "numberOfPublishServiceIdsInBeacon > 127";
1118 return false;
1119 }
1120 legacy_request->sid_beacon_val =
1121 (hidl_request.configParams.includePublishServiceIdsInBeacon ? 0x1
1122 : 0x0) |
1123 (hidl_request.configParams.numberOfPublishServiceIdsInBeacon << 1);
1124 legacy_request->config_subscribe_sid_beacon = 1;
1125 if (hidl_request.configParams.numberOfSubscribeServiceIdsInBeacon > 127) {
1126 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
1127 "numberOfSubscribeServiceIdsInBeacon > 127";
1128 return false;
1129 }
1130 legacy_request->subscribe_sid_beacon_val =
1131 (hidl_request.configParams.includeSubscribeServiceIdsInBeacon ? 0x1
1132 : 0x0) |
1133 (hidl_request.configParams.numberOfSubscribeServiceIdsInBeacon << 1);
1134 legacy_request->config_rssi_window_size = 1;
1135 legacy_request->rssi_window_size_val =
1136 hidl_request.configParams.rssiWindowSize;
1137 legacy_request->config_disc_mac_addr_randomization = 1;
1138 legacy_request->disc_mac_addr_rand_interval_sec =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001139 hidl_request.configParams.macAddressRandomizationIntervalSec;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001140 legacy_request->config_2dot4g_rssi_close = 1;
Nate(Qiang) Jiang18b38eb2019-12-11 12:48:13 -08001141 if (hidl_request.configParams.bandSpecificConfig.size() != 3) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001142 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: "
Nate(Qiang) Jiang18b38eb2019-12-11 12:48:13 -08001143 "bandSpecificConfig.size() != 3";
Roshan Piusabcf78f2017-10-06 16:30:38 -07001144 return false;
1145 }
1146 legacy_request->rssi_close_2dot4g_val =
1147 hidl_request.configParams
1148 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1149 .rssiClose;
1150 legacy_request->config_2dot4g_rssi_middle = 1;
1151 legacy_request->rssi_middle_2dot4g_val =
1152 hidl_request.configParams
1153 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1154 .rssiMiddle;
1155 legacy_request->config_2dot4g_rssi_proximity = 1;
1156 legacy_request->rssi_proximity_2dot4g_val =
1157 hidl_request.configParams
1158 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1159 .rssiCloseProximity;
1160 legacy_request->config_scan_params = 1;
1161 legacy_request->scan_params_val
1162 .dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
1163 hidl_request.configParams
1164 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1165 .dwellTimeMs;
1166 legacy_request->scan_params_val
1167 .scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
1168 hidl_request.configParams
1169 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1170 .scanPeriodSec;
1171 legacy_request->config_dw.config_2dot4g_dw_band =
1172 hidl_request.configParams
1173 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1174 .validDiscoveryWindowIntervalVal;
1175 legacy_request->config_dw.dw_2dot4g_interval_val =
1176 hidl_request.configParams
1177 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1178 .discoveryWindowIntervalVal;
1179 legacy_request->config_5g_rssi_close = 1;
1180 legacy_request->rssi_close_5g_val =
1181 hidl_request.configParams
1182 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1183 .rssiClose;
1184 legacy_request->config_5g_rssi_middle = 1;
1185 legacy_request->rssi_middle_5g_val =
1186 hidl_request.configParams
1187 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1188 .rssiMiddle;
1189 legacy_request->config_5g_rssi_close_proximity = 1;
1190 legacy_request->rssi_close_proximity_5g_val =
1191 hidl_request.configParams
1192 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1193 .rssiCloseProximity;
1194 legacy_request->scan_params_val
1195 .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1196 hidl_request.configParams
1197 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1198 .dwellTimeMs;
1199 legacy_request->scan_params_val
1200 .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1201 hidl_request.configParams
1202 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1203 .scanPeriodSec;
1204 legacy_request->scan_params_val
1205 .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1206 hidl_request.configParams
1207 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1208 .dwellTimeMs;
1209 legacy_request->scan_params_val
1210 .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1211 hidl_request.configParams
1212 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1213 .scanPeriodSec;
1214 legacy_request->config_dw.config_5g_dw_band =
1215 hidl_request.configParams
1216 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1217 .validDiscoveryWindowIntervalVal;
1218 legacy_request->config_dw.dw_5g_interval_val =
1219 hidl_request.configParams
1220 .bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1221 .discoveryWindowIntervalVal;
1222 if (hidl_request.debugConfigs.validClusterIdVals) {
1223 legacy_request->cluster_low =
1224 hidl_request.debugConfigs.clusterIdBottomRangeVal;
1225 legacy_request->cluster_high =
1226 hidl_request.debugConfigs.clusterIdTopRangeVal;
1227 } else { // need 'else' since not configurable in legacy HAL
1228 legacy_request->cluster_low = 0x0000;
1229 legacy_request->cluster_high = 0xFFFF;
1230 }
1231 legacy_request->config_intf_addr =
1232 hidl_request.debugConfigs.validIntfAddrVal;
1233 memcpy(legacy_request->intf_addr_val,
1234 hidl_request.debugConfigs.intfAddrVal.data(), 6);
1235 legacy_request->config_oui = hidl_request.debugConfigs.validOuiVal;
1236 legacy_request->oui_val = hidl_request.debugConfigs.ouiVal;
1237 legacy_request->config_random_factor_force =
1238 hidl_request.debugConfigs.validRandomFactorForceVal;
1239 legacy_request->random_factor_force_val =
1240 hidl_request.debugConfigs.randomFactorForceVal;
1241 legacy_request->config_hop_count_force =
1242 hidl_request.debugConfigs.validHopCountForceVal;
1243 legacy_request->hop_count_force_val =
1244 hidl_request.debugConfigs.hopCountForceVal;
1245 legacy_request->config_24g_channel =
1246 hidl_request.debugConfigs.validDiscoveryChannelVal;
1247 legacy_request->channel_24g_val =
1248 hidl_request.debugConfigs
1249 .discoveryChannelMhzVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1250 legacy_request->config_5g_channel =
1251 hidl_request.debugConfigs.validDiscoveryChannelVal;
1252 legacy_request->channel_5g_val =
1253 hidl_request.debugConfigs
1254 .discoveryChannelMhzVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
1255 legacy_request->config_2dot4g_beacons =
1256 hidl_request.debugConfigs.validUseBeaconsInBandVal;
1257 legacy_request->beacon_2dot4g_val =
1258 hidl_request.debugConfigs
1259 .useBeaconsInBandVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1260 legacy_request->config_5g_beacons =
1261 hidl_request.debugConfigs.validUseBeaconsInBandVal;
1262 legacy_request->beacon_5g_val =
1263 hidl_request.debugConfigs
1264 .useBeaconsInBandVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
1265 legacy_request->config_2dot4g_sdf =
1266 hidl_request.debugConfigs.validUseSdfInBandVal;
1267 legacy_request->sdf_2dot4g_val =
1268 hidl_request.debugConfigs
1269 .useSdfInBandVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
1270 legacy_request->config_5g_sdf =
1271 hidl_request.debugConfigs.validUseSdfInBandVal;
1272 legacy_request->sdf_5g_val =
1273 hidl_request.debugConfigs
1274 .useSdfInBandVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001275
Ahmed ElArabawy83baffd2019-11-15 19:20:41 -08001276 /* TODO: b/145609058
1277 * Missing updates needed to legacy_hal::NanEnableRequest and conversion to
1278 * it for 6GHz band */
1279
Roshan Piusabcf78f2017-10-06 16:30:38 -07001280 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001281}
1282
Ahmed ElArabawy83baffd2019-11-15 19:20:41 -08001283bool convertHidlNanEnableRequest_1_4ToLegacy(
Jimmy Chend460df32019-11-29 17:31:22 +02001284 const V1_4::NanEnableRequest& hidl_request1,
Nate Jiang3ec67812020-08-24 11:04:31 -07001285 const NanConfigRequestSupplemental& hidl_request2,
Etan Cohen9e7a4052017-12-21 13:45:26 -08001286 legacy_hal::NanEnableRequest* legacy_request) {
1287 if (!legacy_request) {
1288 LOG(ERROR)
Ahmed ElArabawy83baffd2019-11-15 19:20:41 -08001289 << "convertHidlNanEnableRequest_1_4ToLegacy: null legacy_request";
Etan Cohen9e7a4052017-12-21 13:45:26 -08001290 return false;
1291 }
1292
1293 *legacy_request = {};
1294 if (!convertHidlNanEnableRequestToLegacy(hidl_request1, legacy_request)) {
1295 return false;
1296 }
1297
1298 legacy_request->config_discovery_beacon_int = 1;
1299 legacy_request->discovery_beacon_interval =
Nate Jiang3ec67812020-08-24 11:04:31 -07001300 hidl_request2.V1_2.discoveryBeaconIntervalMs;
Etan Cohen9e7a4052017-12-21 13:45:26 -08001301 legacy_request->config_nss = 1;
Nate Jiang3ec67812020-08-24 11:04:31 -07001302 legacy_request->nss = hidl_request2.V1_2.numberOfSpatialStreamsInDiscovery;
Etan Cohen9e7a4052017-12-21 13:45:26 -08001303 legacy_request->config_dw_early_termination = 1;
1304 legacy_request->enable_dw_termination =
Nate Jiang3ec67812020-08-24 11:04:31 -07001305 hidl_request2.V1_2.enableDiscoveryWindowEarlyTermination;
Etan Cohen4f5bc6c2017-12-28 13:08:08 -08001306 legacy_request->config_enable_ranging = 1;
Nate Jiang3ec67812020-08-24 11:04:31 -07001307 legacy_request->enable_ranging = hidl_request2.V1_2.enableRanging;
1308
1309 return true;
1310}
1311
1312bool convertHidlNanEnableRequest_1_5ToLegacy(
1313 const V1_4::NanEnableRequest& hidl_request1,
1314 const NanConfigRequestSupplemental& hidl_request2,
1315 legacy_hal::NanEnableRequest* legacy_request) {
1316 if (!legacy_request) {
1317 LOG(ERROR)
1318 << "convertHidlNanEnableRequest_1_5ToLegacy: null legacy_request";
1319 return false;
1320 }
1321
1322 *legacy_request = {};
1323 if (!convertHidlNanEnableRequest_1_4ToLegacy(hidl_request1, hidl_request2,
1324 legacy_request)) {
1325 return false;
1326 }
1327
1328 legacy_request->config_enable_instant_mode = 1;
1329 legacy_request->enable_instant_mode =
1330 hidl_request2.enableInstantCommunicationMode;
1331
1332 return true;
1333}
1334
1335bool convertHidlNanConfigRequest_1_5ToLegacy(
1336 const V1_4::NanConfigRequest& hidl_request1,
1337 const NanConfigRequestSupplemental& hidl_request2,
1338 legacy_hal::NanConfigRequest* legacy_request) {
1339 if (!legacy_request) {
1340 LOG(ERROR)
1341 << "convertHidlNanConfigRequest_1_5ToLegacy: null legacy_request";
1342 return false;
1343 }
1344
1345 *legacy_request = {};
1346 if (!convertHidlNanConfigRequest_1_4ToLegacy(hidl_request1, hidl_request2,
1347 legacy_request)) {
1348 return false;
1349 }
1350
1351 legacy_request->config_enable_instant_mode = 1;
1352 legacy_request->enable_instant_mode =
1353 hidl_request2.enableInstantCommunicationMode;
Etan Cohen9e7a4052017-12-21 13:45:26 -08001354
1355 return true;
1356}
1357
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001358bool convertHidlNanPublishRequestToLegacy(
1359 const NanPublishRequest& hidl_request,
1360 legacy_hal::NanPublishRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001361 if (!legacy_request) {
1362 LOG(ERROR)
1363 << "convertHidlNanPublishRequestToLegacy: null legacy_request";
1364 return false;
1365 }
1366 *legacy_request = {};
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001367
Roshan Piusabcf78f2017-10-06 16:30:38 -07001368 legacy_request->publish_id = hidl_request.baseConfigs.sessionId;
1369 legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
1370 legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
1371 legacy_request->publish_count = hidl_request.baseConfigs.discoveryCount;
1372 legacy_request->service_name_len =
1373 hidl_request.baseConfigs.serviceName.size();
1374 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1375 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: service_name_len "
1376 "too large";
1377 return false;
1378 }
1379 memcpy(legacy_request->service_name,
1380 hidl_request.baseConfigs.serviceName.data(),
1381 legacy_request->service_name_len);
1382 legacy_request->publish_match_indicator = convertHidlNanMatchAlgToLegacy(
1383 hidl_request.baseConfigs.discoveryMatchIndicator);
1384 legacy_request->service_specific_info_len =
1385 hidl_request.baseConfigs.serviceSpecificInfo.size();
1386 if (legacy_request->service_specific_info_len >
1387 NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1388 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1389 "service_specific_info_len too large";
1390 return false;
1391 }
1392 memcpy(legacy_request->service_specific_info,
1393 hidl_request.baseConfigs.serviceSpecificInfo.data(),
1394 legacy_request->service_specific_info_len);
1395 legacy_request->sdea_service_specific_info_len =
Etan Cohena7543a72017-02-17 13:46:19 -08001396 hidl_request.baseConfigs.extendedServiceSpecificInfo.size();
Roshan Piusabcf78f2017-10-06 16:30:38 -07001397 if (legacy_request->sdea_service_specific_info_len >
1398 NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1399 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1400 "sdea_service_specific_info_len too large";
1401 return false;
1402 }
1403 memcpy(legacy_request->sdea_service_specific_info,
1404 hidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
1405 legacy_request->sdea_service_specific_info_len);
1406 legacy_request->rx_match_filter_len =
1407 hidl_request.baseConfigs.rxMatchFilter.size();
1408 if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1409 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1410 "rx_match_filter_len too large";
1411 return false;
1412 }
1413 memcpy(legacy_request->rx_match_filter,
1414 hidl_request.baseConfigs.rxMatchFilter.data(),
1415 legacy_request->rx_match_filter_len);
1416 legacy_request->tx_match_filter_len =
1417 hidl_request.baseConfigs.txMatchFilter.size();
1418 if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1419 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1420 "tx_match_filter_len too large";
1421 return false;
1422 }
1423 memcpy(legacy_request->tx_match_filter,
1424 hidl_request.baseConfigs.txMatchFilter.data(),
1425 legacy_request->tx_match_filter_len);
1426 legacy_request->rssi_threshold_flag =
1427 hidl_request.baseConfigs.useRssiThreshold;
1428 legacy_request->recv_indication_cfg = 0;
1429 legacy_request->recv_indication_cfg |=
1430 hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1
1431 : 0x0;
1432 legacy_request->recv_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001433 hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001434 legacy_request->recv_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001435 hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001436 legacy_request->recv_indication_cfg |= 0x8;
1437 legacy_request->cipher_type =
1438 (unsigned int)hidl_request.baseConfigs.securityConfig.cipherType;
1439 if (hidl_request.baseConfigs.securityConfig.securityType ==
1440 NanDataPathSecurityType::PMK) {
1441 legacy_request->key_info.key_type =
1442 legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1443 legacy_request->key_info.body.pmk_info.pmk_len =
1444 hidl_request.baseConfigs.securityConfig.pmk.size();
1445 if (legacy_request->key_info.body.pmk_info.pmk_len !=
1446 NAN_PMK_INFO_LEN) {
1447 LOG(ERROR)
1448 << "convertHidlNanPublishRequestToLegacy: invalid pmk_len";
1449 return false;
1450 }
1451 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1452 hidl_request.baseConfigs.securityConfig.pmk.data(),
1453 legacy_request->key_info.body.pmk_info.pmk_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001454 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001455 if (hidl_request.baseConfigs.securityConfig.securityType ==
1456 NanDataPathSecurityType::PASSPHRASE) {
1457 legacy_request->key_info.key_type =
1458 legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1459 legacy_request->key_info.body.passphrase_info.passphrase_len =
1460 hidl_request.baseConfigs.securityConfig.passphrase.size();
1461 if (legacy_request->key_info.body.passphrase_info.passphrase_len <
1462 NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1463 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1464 "passphrase_len too small";
1465 return false;
1466 }
1467 if (legacy_request->key_info.body.passphrase_info.passphrase_len >
1468 NAN_SECURITY_MAX_PASSPHRASE_LEN) {
1469 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: "
1470 "passphrase_len too large";
1471 return false;
1472 }
1473 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1474 hidl_request.baseConfigs.securityConfig.passphrase.data(),
1475 legacy_request->key_info.body.passphrase_info.passphrase_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001476 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001477 legacy_request->sdea_params.security_cfg =
1478 (hidl_request.baseConfigs.securityConfig.securityType !=
1479 NanDataPathSecurityType::OPEN)
1480 ? legacy_hal::NAN_DP_CONFIG_SECURITY
Etan Cohenc58619e2017-03-14 14:54:40 -07001481 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001482 legacy_request->sdea_params.ranging_state =
1483 hidl_request.baseConfigs.rangingRequired
1484 ? legacy_hal::NAN_RANGING_ENABLE
1485 : legacy_hal::NAN_RANGING_DISABLE;
1486 legacy_request->ranging_cfg.ranging_interval_msec =
1487 hidl_request.baseConfigs.rangingIntervalMsec;
1488 legacy_request->ranging_cfg.config_ranging_indications =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001489 hidl_request.baseConfigs.configRangingIndications;
Etan Cohen7b8c5d72017-12-14 18:12:04 -08001490 legacy_request->ranging_cfg.distance_ingress_mm =
1491 hidl_request.baseConfigs.distanceIngressCm * 10;
1492 legacy_request->ranging_cfg.distance_egress_mm =
1493 hidl_request.baseConfigs.distanceEgressCm * 10;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001494 legacy_request->ranging_auto_response =
1495 hidl_request.baseConfigs.rangingRequired
1496 ? legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE
1497 : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
1498 legacy_request->sdea_params.range_report =
1499 legacy_hal::NAN_DISABLE_RANGE_REPORT;
1500 legacy_request->publish_type =
1501 convertHidlNanPublishTypeToLegacy(hidl_request.publishType);
1502 legacy_request->tx_type = convertHidlNanTxTypeToLegacy(hidl_request.txType);
1503 legacy_request->service_responder_policy =
1504 hidl_request.autoAcceptDataPathRequests
1505 ? legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL
1506 : legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001507
Roshan Piusabcf78f2017-10-06 16:30:38 -07001508 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001509}
1510
1511bool convertHidlNanSubscribeRequestToLegacy(
1512 const NanSubscribeRequest& hidl_request,
1513 legacy_hal::NanSubscribeRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001514 if (!legacy_request) {
1515 LOG(ERROR)
1516 << "convertHidlNanSubscribeRequestToLegacy: legacy_request is null";
1517 return false;
1518 }
1519 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001520
Roshan Piusabcf78f2017-10-06 16:30:38 -07001521 legacy_request->subscribe_id = hidl_request.baseConfigs.sessionId;
1522 legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
1523 legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
1524 legacy_request->subscribe_count = hidl_request.baseConfigs.discoveryCount;
1525 legacy_request->service_name_len =
1526 hidl_request.baseConfigs.serviceName.size();
1527 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1528 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1529 "service_name_len too large";
1530 return false;
1531 }
1532 memcpy(legacy_request->service_name,
1533 hidl_request.baseConfigs.serviceName.data(),
1534 legacy_request->service_name_len);
1535 legacy_request->subscribe_match_indicator = convertHidlNanMatchAlgToLegacy(
1536 hidl_request.baseConfigs.discoveryMatchIndicator);
1537 legacy_request->service_specific_info_len =
1538 hidl_request.baseConfigs.serviceSpecificInfo.size();
1539 if (legacy_request->service_specific_info_len >
1540 NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1541 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1542 "service_specific_info_len too large";
1543 return false;
1544 }
1545 memcpy(legacy_request->service_specific_info,
1546 hidl_request.baseConfigs.serviceSpecificInfo.data(),
1547 legacy_request->service_specific_info_len);
1548 legacy_request->sdea_service_specific_info_len =
Etan Cohena7543a72017-02-17 13:46:19 -08001549 hidl_request.baseConfigs.extendedServiceSpecificInfo.size();
Roshan Piusabcf78f2017-10-06 16:30:38 -07001550 if (legacy_request->sdea_service_specific_info_len >
1551 NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1552 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1553 "sdea_service_specific_info_len too large";
1554 return false;
1555 }
1556 memcpy(legacy_request->sdea_service_specific_info,
1557 hidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
1558 legacy_request->sdea_service_specific_info_len);
1559 legacy_request->rx_match_filter_len =
1560 hidl_request.baseConfigs.rxMatchFilter.size();
1561 if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1562 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1563 "rx_match_filter_len too large";
1564 return false;
1565 }
1566 memcpy(legacy_request->rx_match_filter,
1567 hidl_request.baseConfigs.rxMatchFilter.data(),
1568 legacy_request->rx_match_filter_len);
1569 legacy_request->tx_match_filter_len =
1570 hidl_request.baseConfigs.txMatchFilter.size();
1571 if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
1572 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1573 "tx_match_filter_len too large";
1574 return false;
1575 }
1576 memcpy(legacy_request->tx_match_filter,
1577 hidl_request.baseConfigs.txMatchFilter.data(),
1578 legacy_request->tx_match_filter_len);
1579 legacy_request->rssi_threshold_flag =
1580 hidl_request.baseConfigs.useRssiThreshold;
1581 legacy_request->recv_indication_cfg = 0;
1582 legacy_request->recv_indication_cfg |=
1583 hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1
1584 : 0x0;
1585 legacy_request->recv_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001586 hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001587 legacy_request->recv_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001588 hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001589 legacy_request->cipher_type =
1590 (unsigned int)hidl_request.baseConfigs.securityConfig.cipherType;
1591 if (hidl_request.baseConfigs.securityConfig.securityType ==
1592 NanDataPathSecurityType::PMK) {
1593 legacy_request->key_info.key_type =
1594 legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1595 legacy_request->key_info.body.pmk_info.pmk_len =
1596 hidl_request.baseConfigs.securityConfig.pmk.size();
1597 if (legacy_request->key_info.body.pmk_info.pmk_len !=
1598 NAN_PMK_INFO_LEN) {
1599 LOG(ERROR)
1600 << "convertHidlNanSubscribeRequestToLegacy: invalid pmk_len";
1601 return false;
1602 }
1603 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1604 hidl_request.baseConfigs.securityConfig.pmk.data(),
1605 legacy_request->key_info.body.pmk_info.pmk_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001606 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001607 if (hidl_request.baseConfigs.securityConfig.securityType ==
1608 NanDataPathSecurityType::PASSPHRASE) {
1609 legacy_request->key_info.key_type =
1610 legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1611 legacy_request->key_info.body.passphrase_info.passphrase_len =
1612 hidl_request.baseConfigs.securityConfig.passphrase.size();
1613 if (legacy_request->key_info.body.passphrase_info.passphrase_len <
1614 NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1615 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1616 "passphrase_len too small";
1617 return false;
1618 }
1619 if (legacy_request->key_info.body.passphrase_info.passphrase_len >
1620 NAN_SECURITY_MAX_PASSPHRASE_LEN) {
1621 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1622 "passphrase_len too large";
1623 return false;
1624 }
1625 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1626 hidl_request.baseConfigs.securityConfig.passphrase.data(),
1627 legacy_request->key_info.body.passphrase_info.passphrase_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001628 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001629 legacy_request->sdea_params.security_cfg =
1630 (hidl_request.baseConfigs.securityConfig.securityType !=
1631 NanDataPathSecurityType::OPEN)
1632 ? legacy_hal::NAN_DP_CONFIG_SECURITY
1633 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
1634 legacy_request->sdea_params.ranging_state =
1635 hidl_request.baseConfigs.rangingRequired
1636 ? legacy_hal::NAN_RANGING_ENABLE
1637 : legacy_hal::NAN_RANGING_DISABLE;
1638 legacy_request->ranging_cfg.ranging_interval_msec =
1639 hidl_request.baseConfigs.rangingIntervalMsec;
1640 legacy_request->ranging_cfg.config_ranging_indications =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001641 hidl_request.baseConfigs.configRangingIndications;
Etan Cohen7b8c5d72017-12-14 18:12:04 -08001642 legacy_request->ranging_cfg.distance_ingress_mm =
1643 hidl_request.baseConfigs.distanceIngressCm * 10;
1644 legacy_request->ranging_cfg.distance_egress_mm =
1645 hidl_request.baseConfigs.distanceEgressCm * 10;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001646 legacy_request->ranging_auto_response =
1647 hidl_request.baseConfigs.rangingRequired
1648 ? legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE
1649 : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
1650 legacy_request->sdea_params.range_report =
1651 legacy_hal::NAN_DISABLE_RANGE_REPORT;
1652 legacy_request->subscribe_type =
1653 convertHidlNanSubscribeTypeToLegacy(hidl_request.subscribeType);
1654 legacy_request->serviceResponseFilter =
1655 convertHidlNanSrfTypeToLegacy(hidl_request.srfType);
1656 legacy_request->serviceResponseInclude =
1657 hidl_request.srfRespondIfInAddressSet
1658 ? legacy_hal::NAN_SRF_INCLUDE_RESPOND
1659 : legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
1660 legacy_request->useServiceResponseFilter =
1661 hidl_request.shouldUseSrf ? legacy_hal::NAN_USE_SRF
1662 : legacy_hal::NAN_DO_NOT_USE_SRF;
1663 legacy_request->ssiRequiredForMatchIndication =
1664 hidl_request.isSsiRequiredForMatch
1665 ? legacy_hal::NAN_SSI_REQUIRED_IN_MATCH_IND
1666 : legacy_hal::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND;
1667 legacy_request->num_intf_addr_present = hidl_request.intfAddr.size();
1668 if (legacy_request->num_intf_addr_present > NAN_MAX_SUBSCRIBE_MAX_ADDRESS) {
1669 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: "
1670 "num_intf_addr_present - too many";
1671 return false;
1672 }
1673 for (int i = 0; i < legacy_request->num_intf_addr_present; i++) {
1674 memcpy(legacy_request->intf_addr[i], hidl_request.intfAddr[i].data(),
1675 6);
1676 }
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001677
Roshan Piusabcf78f2017-10-06 16:30:38 -07001678 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001679}
1680
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001681bool convertHidlNanTransmitFollowupRequestToLegacy(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001682 const NanTransmitFollowupRequest& hidl_request,
1683 legacy_hal::NanTransmitFollowupRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001684 if (!legacy_request) {
1685 LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
1686 "legacy_request is null";
1687 return false;
1688 }
1689 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001690
Roshan Piusabcf78f2017-10-06 16:30:38 -07001691 legacy_request->publish_subscribe_id = hidl_request.discoverySessionId;
1692 legacy_request->requestor_instance_id = hidl_request.peerId;
1693 memcpy(legacy_request->addr, hidl_request.addr.data(), 6);
1694 legacy_request->priority = hidl_request.isHighPriority
1695 ? legacy_hal::NAN_TX_PRIORITY_HIGH
1696 : legacy_hal::NAN_TX_PRIORITY_NORMAL;
1697 legacy_request->dw_or_faw = hidl_request.shouldUseDiscoveryWindow
1698 ? legacy_hal::NAN_TRANSMIT_IN_DW
1699 : legacy_hal::NAN_TRANSMIT_IN_FAW;
1700 legacy_request->service_specific_info_len =
1701 hidl_request.serviceSpecificInfo.size();
1702 if (legacy_request->service_specific_info_len >
1703 NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
1704 LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
1705 "service_specific_info_len too large";
1706 return false;
1707 }
1708 memcpy(legacy_request->service_specific_info,
1709 hidl_request.serviceSpecificInfo.data(),
1710 legacy_request->service_specific_info_len);
1711 legacy_request->sdea_service_specific_info_len =
1712 hidl_request.extendedServiceSpecificInfo.size();
1713 if (legacy_request->sdea_service_specific_info_len >
1714 NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
1715 LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: "
1716 "sdea_service_specific_info_len too large";
1717 return false;
1718 }
1719 memcpy(legacy_request->sdea_service_specific_info,
1720 hidl_request.extendedServiceSpecificInfo.data(),
1721 legacy_request->sdea_service_specific_info_len);
1722 legacy_request->recv_indication_cfg =
1723 hidl_request.disableFollowupResultIndication ? 0x1 : 0x0;
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001724
Roshan Piusabcf78f2017-10-06 16:30:38 -07001725 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001726}
1727
1728bool convertHidlNanConfigRequestToLegacy(
Jimmy Chend460df32019-11-29 17:31:22 +02001729 const V1_4::NanConfigRequest& hidl_request,
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001730 legacy_hal::NanConfigRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001731 if (!legacy_request) {
1732 LOG(ERROR)
1733 << "convertHidlNanConfigRequestToLegacy: legacy_request is null";
1734 return false;
1735 }
1736 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001737
Roshan Piusabcf78f2017-10-06 16:30:38 -07001738 // TODO: b/34059183 tracks missing configurations in legacy HAL or uknown
1739 // defaults
1740 legacy_request->master_pref = hidl_request.masterPref;
1741 legacy_request->discovery_indication_cfg = 0;
1742 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001743 hidl_request.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001744 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001745 hidl_request.disableStartedClusterIndication ? 0x2 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001746 legacy_request->discovery_indication_cfg |=
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001747 hidl_request.disableJoinedClusterIndication ? 0x4 : 0x0;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001748 legacy_request->config_sid_beacon = 1;
1749 if (hidl_request.numberOfPublishServiceIdsInBeacon > 127) {
1750 LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: "
1751 "numberOfPublishServiceIdsInBeacon > 127";
1752 return false;
1753 }
1754 legacy_request->sid_beacon =
1755 (hidl_request.includePublishServiceIdsInBeacon ? 0x1 : 0x0) |
1756 (hidl_request.numberOfPublishServiceIdsInBeacon << 1);
1757 legacy_request->config_subscribe_sid_beacon = 1;
1758 if (hidl_request.numberOfSubscribeServiceIdsInBeacon > 127) {
1759 LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: "
1760 "numberOfSubscribeServiceIdsInBeacon > 127";
1761 return false;
1762 }
1763 legacy_request->subscribe_sid_beacon_val =
1764 (hidl_request.includeSubscribeServiceIdsInBeacon ? 0x1 : 0x0) |
1765 (hidl_request.numberOfSubscribeServiceIdsInBeacon << 1);
1766 legacy_request->config_rssi_window_size = 1;
1767 legacy_request->rssi_window_size_val = hidl_request.rssiWindowSize;
1768 legacy_request->config_disc_mac_addr_randomization = 1;
1769 legacy_request->disc_mac_addr_rand_interval_sec =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001770 hidl_request.macAddressRandomizationIntervalSec;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001771 /* TODO : missing
1772 legacy_request->config_2dot4g_rssi_close = 1;
1773 legacy_request->rssi_close_2dot4g_val =
1774 hidl_request.bandSpecificConfig[
1775 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiClose;
1776 legacy_request->config_2dot4g_rssi_middle = 1;
1777 legacy_request->rssi_middle_2dot4g_val =
1778 hidl_request.bandSpecificConfig[
1779 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiMiddle;
1780 legacy_request->config_2dot4g_rssi_proximity = 1;
1781 legacy_request->rssi_proximity_2dot4g_val =
1782 hidl_request.bandSpecificConfig[
1783 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiCloseProximity;
1784 */
1785 legacy_request->config_scan_params = 1;
1786 legacy_request->scan_params_val
1787 .dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
1788 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1789 .dwellTimeMs;
1790 legacy_request->scan_params_val
1791 .scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
1792 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1793 .scanPeriodSec;
1794 legacy_request->config_dw.config_2dot4g_dw_band =
1795 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1796 .validDiscoveryWindowIntervalVal;
1797 legacy_request->config_dw.dw_2dot4g_interval_val =
1798 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
1799 .discoveryWindowIntervalVal;
1800 /* TODO: missing
1801 legacy_request->config_5g_rssi_close = 1;
1802 legacy_request->rssi_close_5g_val =
1803 hidl_request.bandSpecificConfig[
1804 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiClose;
1805 legacy_request->config_5g_rssi_middle = 1;
1806 legacy_request->rssi_middle_5g_val =
1807 hidl_request.bandSpecificConfig[
1808 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiMiddle;
1809 */
1810 legacy_request->config_5g_rssi_close_proximity = 1;
1811 legacy_request->rssi_close_proximity_5g_val =
1812 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1813 .rssiCloseProximity;
1814 legacy_request->scan_params_val
1815 .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1816 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1817 .dwellTimeMs;
1818 legacy_request->scan_params_val
1819 .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
1820 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1821 .scanPeriodSec;
1822 legacy_request->scan_params_val
1823 .dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1824 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1825 .dwellTimeMs;
1826 legacy_request->scan_params_val
1827 .scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
1828 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1829 .scanPeriodSec;
1830 legacy_request->config_dw.config_5g_dw_band =
1831 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1832 .validDiscoveryWindowIntervalVal;
1833 legacy_request->config_dw.dw_5g_interval_val =
1834 hidl_request.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
1835 .discoveryWindowIntervalVal;
Ahmed ElArabawy83baffd2019-11-15 19:20:41 -08001836 /* TODO: b/145609058
1837 * Missing updates needed to legacy_hal::NanConfigRequest and conversion to
1838 * it for 6GHz band */
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001839
Roshan Piusabcf78f2017-10-06 16:30:38 -07001840 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001841}
1842
Ahmed ElArabawy83baffd2019-11-15 19:20:41 -08001843bool convertHidlNanConfigRequest_1_4ToLegacy(
Jimmy Chend460df32019-11-29 17:31:22 +02001844 const V1_4::NanConfigRequest& hidl_request1,
Nate Jiang3ec67812020-08-24 11:04:31 -07001845 const NanConfigRequestSupplemental& hidl_request2,
Etan Cohen9e7a4052017-12-21 13:45:26 -08001846 legacy_hal::NanConfigRequest* legacy_request) {
1847 if (!legacy_request) {
Ahmed ElArabawy83baffd2019-11-15 19:20:41 -08001848 LOG(ERROR) << "convertHidlNanConfigRequest_1_4ToLegacy: legacy_request "
Etan Cohen9e7a4052017-12-21 13:45:26 -08001849 "is null";
1850 return false;
1851 }
1852
1853 *legacy_request = {};
1854 if (!convertHidlNanConfigRequestToLegacy(hidl_request1, legacy_request)) {
1855 return false;
1856 }
1857
1858 legacy_request->config_discovery_beacon_int = 1;
1859 legacy_request->discovery_beacon_interval =
Nate Jiang3ec67812020-08-24 11:04:31 -07001860 hidl_request2.V1_2.discoveryBeaconIntervalMs;
Etan Cohen9e7a4052017-12-21 13:45:26 -08001861 legacy_request->config_nss = 1;
Nate Jiang3ec67812020-08-24 11:04:31 -07001862 legacy_request->nss = hidl_request2.V1_2.numberOfSpatialStreamsInDiscovery;
Etan Cohen9e7a4052017-12-21 13:45:26 -08001863 legacy_request->config_dw_early_termination = 1;
1864 legacy_request->enable_dw_termination =
Nate Jiang3ec67812020-08-24 11:04:31 -07001865 hidl_request2.V1_2.enableDiscoveryWindowEarlyTermination;
Etan Cohen4f5bc6c2017-12-28 13:08:08 -08001866 legacy_request->config_enable_ranging = 1;
Nate Jiang3ec67812020-08-24 11:04:31 -07001867 legacy_request->enable_ranging = hidl_request2.V1_2.enableRanging;
Etan Cohen9e7a4052017-12-21 13:45:26 -08001868
1869 return true;
1870}
1871
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001872bool convertHidlNanDataPathInitiatorRequestToLegacy(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001873 const NanInitiateDataPathRequest& hidl_request,
1874 legacy_hal::NanDataPathInitiatorRequest* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001875 if (!legacy_request) {
1876 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
1877 "legacy_request is null";
1878 return false;
1879 }
1880 *legacy_request = {};
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001881
Roshan Piusabcf78f2017-10-06 16:30:38 -07001882 legacy_request->requestor_instance_id = hidl_request.peerId;
1883 memcpy(legacy_request->peer_disc_mac_addr,
1884 hidl_request.peerDiscMacAddr.data(), 6);
1885 legacy_request->channel_request_type =
1886 convertHidlNanDataPathChannelCfgToLegacy(
1887 hidl_request.channelRequestType);
1888 legacy_request->channel = hidl_request.channel;
Etan Cohen1cefaf62019-11-25 11:41:58 -08001889 if (strnlen(hidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
1890 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
1891 "ifaceName too long";
1892 return false;
1893 }
1894 strncpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str(),
1895 IFNAMSIZ + 1);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001896 legacy_request->ndp_cfg.security_cfg =
1897 (hidl_request.securityConfig.securityType !=
1898 NanDataPathSecurityType::OPEN)
1899 ? legacy_hal::NAN_DP_CONFIG_SECURITY
Etan Cohenc58619e2017-03-14 14:54:40 -07001900 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001901 legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
1902 if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
1903 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
1904 "ndp_app_info_len too large";
1905 return false;
Etan Cohenc58619e2017-03-14 14:54:40 -07001906 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001907 memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
1908 legacy_request->app_info.ndp_app_info_len);
1909 legacy_request->cipher_type =
1910 (unsigned int)hidl_request.securityConfig.cipherType;
1911 if (hidl_request.securityConfig.securityType ==
1912 NanDataPathSecurityType::PMK) {
1913 legacy_request->key_info.key_type =
1914 legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
1915 legacy_request->key_info.body.pmk_info.pmk_len =
1916 hidl_request.securityConfig.pmk.size();
1917 if (legacy_request->key_info.body.pmk_info.pmk_len !=
1918 NAN_PMK_INFO_LEN) {
1919 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
1920 "invalid pmk_len";
1921 return false;
1922 }
1923 memcpy(legacy_request->key_info.body.pmk_info.pmk,
1924 hidl_request.securityConfig.pmk.data(),
1925 legacy_request->key_info.body.pmk_info.pmk_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001926 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001927 if (hidl_request.securityConfig.securityType ==
1928 NanDataPathSecurityType::PASSPHRASE) {
1929 legacy_request->key_info.key_type =
1930 legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
1931 legacy_request->key_info.body.passphrase_info.passphrase_len =
1932 hidl_request.securityConfig.passphrase.size();
1933 if (legacy_request->key_info.body.passphrase_info.passphrase_len <
1934 NAN_SECURITY_MIN_PASSPHRASE_LEN) {
1935 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
1936 "passphrase_len too small";
1937 return false;
1938 }
1939 if (legacy_request->key_info.body.passphrase_info.passphrase_len >
1940 NAN_SECURITY_MAX_PASSPHRASE_LEN) {
1941 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
1942 "passphrase_len too large";
1943 return false;
1944 }
1945 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
1946 hidl_request.securityConfig.passphrase.data(),
1947 legacy_request->key_info.body.passphrase_info.passphrase_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07001948 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001949 legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
1950 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
1951 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: "
1952 "service_name_len too large";
1953 return false;
1954 }
1955 memcpy(legacy_request->service_name,
1956 hidl_request.serviceNameOutOfBand.data(),
1957 legacy_request->service_name_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001958
Roshan Piusabcf78f2017-10-06 16:30:38 -07001959 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001960}
1961
1962bool convertHidlNanDataPathIndicationResponseToLegacy(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08001963 const NanRespondToDataPathIndicationRequest& hidl_request,
1964 legacy_hal::NanDataPathIndicationResponse* legacy_request) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07001965 if (!legacy_request) {
1966 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
1967 "legacy_request is null";
1968 return false;
1969 }
1970 *legacy_request = {};
Roshan Piusf5f51fd2016-12-01 13:54:24 -08001971
Roshan Piusabcf78f2017-10-06 16:30:38 -07001972 legacy_request->rsp_code = hidl_request.acceptRequest
1973 ? legacy_hal::NAN_DP_REQUEST_ACCEPT
1974 : legacy_hal::NAN_DP_REQUEST_REJECT;
1975 legacy_request->ndp_instance_id = hidl_request.ndpInstanceId;
Etan Cohen1cefaf62019-11-25 11:41:58 -08001976 if (strnlen(hidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
1977 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
1978 "ifaceName too long";
1979 return false;
1980 }
1981 strncpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str(),
1982 IFNAMSIZ + 1);
Roshan Piusabcf78f2017-10-06 16:30:38 -07001983 legacy_request->ndp_cfg.security_cfg =
1984 (hidl_request.securityConfig.securityType !=
1985 NanDataPathSecurityType::OPEN)
1986 ? legacy_hal::NAN_DP_CONFIG_SECURITY
Etan Cohenc58619e2017-03-14 14:54:40 -07001987 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
Roshan Piusabcf78f2017-10-06 16:30:38 -07001988 legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
1989 if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
1990 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
1991 "ndp_app_info_len too large";
1992 return false;
Etan Cohenc58619e2017-03-14 14:54:40 -07001993 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07001994 memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
1995 legacy_request->app_info.ndp_app_info_len);
1996 legacy_request->cipher_type =
1997 (unsigned int)hidl_request.securityConfig.cipherType;
1998 if (hidl_request.securityConfig.securityType ==
1999 NanDataPathSecurityType::PMK) {
2000 legacy_request->key_info.key_type =
2001 legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
2002 legacy_request->key_info.body.pmk_info.pmk_len =
2003 hidl_request.securityConfig.pmk.size();
2004 if (legacy_request->key_info.body.pmk_info.pmk_len !=
2005 NAN_PMK_INFO_LEN) {
2006 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2007 "invalid pmk_len";
2008 return false;
2009 }
2010 memcpy(legacy_request->key_info.body.pmk_info.pmk,
2011 hidl_request.securityConfig.pmk.data(),
2012 legacy_request->key_info.body.pmk_info.pmk_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07002013 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002014 if (hidl_request.securityConfig.securityType ==
2015 NanDataPathSecurityType::PASSPHRASE) {
2016 legacy_request->key_info.key_type =
2017 legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
2018 legacy_request->key_info.body.passphrase_info.passphrase_len =
2019 hidl_request.securityConfig.passphrase.size();
2020 if (legacy_request->key_info.body.passphrase_info.passphrase_len <
2021 NAN_SECURITY_MIN_PASSPHRASE_LEN) {
2022 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2023 "passphrase_len too small";
2024 return false;
2025 }
2026 if (legacy_request->key_info.body.passphrase_info.passphrase_len >
2027 NAN_SECURITY_MAX_PASSPHRASE_LEN) {
2028 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2029 "passphrase_len too large";
2030 return false;
2031 }
2032 memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
2033 hidl_request.securityConfig.passphrase.data(),
2034 legacy_request->key_info.body.passphrase_info.passphrase_len);
Etan Cohenc58619e2017-03-14 14:54:40 -07002035 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002036 legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size();
2037 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
2038 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: "
2039 "service_name_len too large";
2040 return false;
2041 }
2042 memcpy(legacy_request->service_name,
2043 hidl_request.serviceNameOutOfBand.data(),
2044 legacy_request->service_name_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002045
Roshan Piusabcf78f2017-10-06 16:30:38 -07002046 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002047}
2048
2049bool convertLegacyNanResponseHeaderToHidl(
2050 const legacy_hal::NanResponseMsg& legacy_response,
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002051 WifiNanStatus* wifiNanStatus) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002052 if (!wifiNanStatus) {
2053 LOG(ERROR)
2054 << "convertLegacyNanResponseHeaderToHidl: wifiNanStatus is null";
2055 return false;
2056 }
2057 *wifiNanStatus = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002058
Roshan Piusabcf78f2017-10-06 16:30:38 -07002059 convertToWifiNanStatus(legacy_response.status, legacy_response.nan_error,
2060 sizeof(legacy_response.nan_error), wifiNanStatus);
2061 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002062}
2063
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002064bool convertLegacyNanCapabilitiesResponseToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002065 const legacy_hal::NanCapabilities& legacy_response,
2066 NanCapabilities* hidl_response) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002067 if (!hidl_response) {
2068 LOG(ERROR) << "convertLegacyNanCapabilitiesResponseToHidl: "
2069 "hidl_response is null";
2070 return false;
2071 }
2072 *hidl_response = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002073
Nate Jiang3ec67812020-08-24 11:04:31 -07002074 hidl_response->V1_0.maxConcurrentClusters =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002075 legacy_response.max_concurrent_nan_clusters;
Nate Jiang3ec67812020-08-24 11:04:31 -07002076 hidl_response->V1_0.maxPublishes = legacy_response.max_publishes;
2077 hidl_response->V1_0.maxSubscribes = legacy_response.max_subscribes;
2078 hidl_response->V1_0.maxServiceNameLen =
2079 legacy_response.max_service_name_len;
2080 hidl_response->V1_0.maxMatchFilterLen =
2081 legacy_response.max_match_filter_len;
2082 hidl_response->V1_0.maxTotalMatchFilterLen =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002083 legacy_response.max_total_match_filter_len;
Nate Jiang3ec67812020-08-24 11:04:31 -07002084 hidl_response->V1_0.maxServiceSpecificInfoLen =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002085 legacy_response.max_service_specific_info_len;
Nate Jiang3ec67812020-08-24 11:04:31 -07002086 hidl_response->V1_0.maxExtendedServiceSpecificInfoLen =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002087 legacy_response.max_sdea_service_specific_info_len;
Nate Jiang3ec67812020-08-24 11:04:31 -07002088 hidl_response->V1_0.maxNdiInterfaces = legacy_response.max_ndi_interfaces;
2089 hidl_response->V1_0.maxNdpSessions = legacy_response.max_ndp_sessions;
2090 hidl_response->V1_0.maxAppInfoLen = legacy_response.max_app_info_len;
2091 hidl_response->V1_0.maxQueuedTransmitFollowupMsgs =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002092 legacy_response.max_queued_transmit_followup_msgs;
Nate Jiang3ec67812020-08-24 11:04:31 -07002093 hidl_response->V1_0.maxSubscribeInterfaceAddresses =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002094 legacy_response.max_subscribe_address;
Nate Jiang3ec67812020-08-24 11:04:31 -07002095 hidl_response->V1_0.supportedCipherSuites =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002096 legacy_response.cipher_suites_supported;
Nate Jiang3ec67812020-08-24 11:04:31 -07002097 hidl_response->instantCommunicationModeSupportFlag =
2098 legacy_response.is_instant_mode_supported;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002099
Roshan Piusabcf78f2017-10-06 16:30:38 -07002100 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002101}
2102
Roshan Piusabcf78f2017-10-06 16:30:38 -07002103bool convertLegacyNanMatchIndToHidl(const legacy_hal::NanMatchInd& legacy_ind,
2104 NanMatchInd* hidl_ind) {
2105 if (!hidl_ind) {
2106 LOG(ERROR) << "convertLegacyNanMatchIndToHidl: hidl_ind is null";
2107 return false;
2108 }
2109 *hidl_ind = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002110
Roshan Piusabcf78f2017-10-06 16:30:38 -07002111 hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
2112 hidl_ind->peerId = legacy_ind.requestor_instance_id;
2113 hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
2114 hidl_ind->serviceSpecificInfo =
2115 std::vector<uint8_t>(legacy_ind.service_specific_info,
2116 legacy_ind.service_specific_info +
2117 legacy_ind.service_specific_info_len);
2118 hidl_ind->extendedServiceSpecificInfo =
2119 std::vector<uint8_t>(legacy_ind.sdea_service_specific_info,
2120 legacy_ind.sdea_service_specific_info +
2121 legacy_ind.sdea_service_specific_info_len);
2122 hidl_ind->matchFilter = std::vector<uint8_t>(
2123 legacy_ind.sdf_match_filter,
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002124 legacy_ind.sdf_match_filter + legacy_ind.sdf_match_filter_len);
Roshan Piusabcf78f2017-10-06 16:30:38 -07002125 hidl_ind->matchOccuredInBeaconFlag = legacy_ind.match_occured_flag == 1;
2126 hidl_ind->outOfResourceFlag = legacy_ind.out_of_resource_flag == 1;
2127 hidl_ind->rssiValue = legacy_ind.rssi_value;
2128 hidl_ind->peerCipherType = (NanCipherSuiteType)legacy_ind.peer_cipher_type;
2129 hidl_ind->peerRequiresSecurityEnabledInNdp =
2130 legacy_ind.peer_sdea_params.security_cfg ==
2131 legacy_hal::NAN_DP_CONFIG_SECURITY;
2132 hidl_ind->peerRequiresRanging = legacy_ind.peer_sdea_params.ranging_state ==
2133 legacy_hal::NAN_RANGING_ENABLE;
2134 hidl_ind->rangingMeasurementInCm =
Etan Cohen7b8c5d72017-12-14 18:12:04 -08002135 legacy_ind.range_info.range_measurement_mm / 10;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002136 hidl_ind->rangingIndicationType = legacy_ind.range_info.ranging_event_type;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002137
Roshan Piusabcf78f2017-10-06 16:30:38 -07002138 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002139}
2140
2141bool convertLegacyNanFollowupIndToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002142 const legacy_hal::NanFollowupInd& legacy_ind,
2143 NanFollowupReceivedInd* hidl_ind) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002144 if (!hidl_ind) {
2145 LOG(ERROR) << "convertLegacyNanFollowupIndToHidl: hidl_ind is null";
2146 return false;
2147 }
2148 *hidl_ind = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002149
Roshan Piusabcf78f2017-10-06 16:30:38 -07002150 hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
2151 hidl_ind->peerId = legacy_ind.requestor_instance_id;
2152 hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
2153 hidl_ind->receivedInFaw = legacy_ind.dw_or_faw == 1;
2154 hidl_ind->serviceSpecificInfo =
2155 std::vector<uint8_t>(legacy_ind.service_specific_info,
2156 legacy_ind.service_specific_info +
2157 legacy_ind.service_specific_info_len);
2158 hidl_ind->extendedServiceSpecificInfo =
2159 std::vector<uint8_t>(legacy_ind.sdea_service_specific_info,
2160 legacy_ind.sdea_service_specific_info +
2161 legacy_ind.sdea_service_specific_info_len);
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002162
Roshan Piusabcf78f2017-10-06 16:30:38 -07002163 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002164}
2165
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002166bool convertLegacyNanDataPathRequestIndToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002167 const legacy_hal::NanDataPathRequestInd& legacy_ind,
2168 NanDataPathRequestInd* hidl_ind) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002169 if (!hidl_ind) {
2170 LOG(ERROR)
2171 << "convertLegacyNanDataPathRequestIndToHidl: hidl_ind is null";
2172 return false;
2173 }
2174 *hidl_ind = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002175
Roshan Piusabcf78f2017-10-06 16:30:38 -07002176 hidl_ind->discoverySessionId = legacy_ind.service_instance_id;
2177 hidl_ind->peerDiscMacAddr =
2178 hidl_array<uint8_t, 6>(legacy_ind.peer_disc_mac_addr);
2179 hidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
2180 hidl_ind->securityRequired =
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002181 legacy_ind.ndp_cfg.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002182 hidl_ind->appInfo =
2183 std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info,
2184 legacy_ind.app_info.ndp_app_info +
2185 legacy_ind.app_info.ndp_app_info_len);
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002186
Roshan Piusabcf78f2017-10-06 16:30:38 -07002187 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002188}
2189
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002190bool convertLegacyNdpChannelInfoToHidl(
2191 const legacy_hal::NanChannelInfo& legacy_struct,
Jong Wook Kimda830c92018-07-23 15:29:38 -07002192 V1_2::NanDataPathChannelInfo* hidl_struct) {
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002193 if (!hidl_struct) {
2194 LOG(ERROR) << "convertLegacyNdpChannelInfoToHidl: hidl_struct is null";
2195 return false;
2196 }
2197 *hidl_struct = {};
2198
2199 hidl_struct->channelFreq = legacy_struct.channel;
Etan Cohenb1b7a822018-02-07 14:44:32 -08002200 hidl_struct->channelBandwidth = convertLegacyWifiChannelWidthToHidl(
2201 (legacy_hal::wifi_channel_width)legacy_struct.bandwidth);
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002202 hidl_struct->numSpatialStreams = legacy_struct.nss;
2203
2204 return true;
2205}
2206
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002207bool convertLegacyNanDataPathConfirmIndToHidl(
Etan Cohenf01bcaa2016-12-25 09:42:21 -08002208 const legacy_hal::NanDataPathConfirmInd& legacy_ind,
Jong Wook Kimda830c92018-07-23 15:29:38 -07002209 V1_2::NanDataPathConfirmInd* hidl_ind) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002210 if (!hidl_ind) {
2211 LOG(ERROR)
2212 << "convertLegacyNanDataPathConfirmIndToHidl: hidl_ind is null";
2213 return false;
2214 }
2215 *hidl_ind = {};
Roshan Pius590744b2017-03-02 07:24:41 -08002216
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002217 hidl_ind->V1_0.ndpInstanceId = legacy_ind.ndp_instance_id;
2218 hidl_ind->V1_0.dataPathSetupSuccess =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002219 legacy_ind.rsp_code == legacy_hal::NAN_DP_REQUEST_ACCEPT;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002220 hidl_ind->V1_0.peerNdiMacAddr =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002221 hidl_array<uint8_t, 6>(legacy_ind.peer_ndi_mac_addr);
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002222 hidl_ind->V1_0.appInfo =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002223 std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info,
2224 legacy_ind.app_info.ndp_app_info +
2225 legacy_ind.app_info.ndp_app_info_len);
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002226 hidl_ind->V1_0.status.status =
Roshan Piusabcf78f2017-10-06 16:30:38 -07002227 convertLegacyNanStatusTypeToHidl(legacy_ind.reason_code);
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002228 hidl_ind->V1_0.status.description = ""; // TODO: b/34059183
2229
Jong Wook Kimda830c92018-07-23 15:29:38 -07002230 std::vector<V1_2::NanDataPathChannelInfo> channelInfo;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002231 for (unsigned int i = 0; i < legacy_ind.num_channels; ++i) {
Jong Wook Kimda830c92018-07-23 15:29:38 -07002232 V1_2::NanDataPathChannelInfo hidl_struct;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002233 if (!convertLegacyNdpChannelInfoToHidl(legacy_ind.channel_info[i],
2234 &hidl_struct)) {
2235 return false;
2236 }
2237 channelInfo.push_back(hidl_struct);
2238 }
2239 hidl_ind->channelInfo = channelInfo;
2240
2241 return true;
2242}
2243
2244bool convertLegacyNanDataPathScheduleUpdateIndToHidl(
2245 const legacy_hal::NanDataPathScheduleUpdateInd& legacy_ind,
Jong Wook Kimda830c92018-07-23 15:29:38 -07002246 V1_2::NanDataPathScheduleUpdateInd* hidl_ind) {
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002247 if (!hidl_ind) {
2248 LOG(ERROR) << "convertLegacyNanDataPathScheduleUpdateIndToHidl: "
2249 "hidl_ind is null";
2250 return false;
2251 }
2252 *hidl_ind = {};
2253
2254 hidl_ind->peerDiscoveryAddress =
2255 hidl_array<uint8_t, 6>(legacy_ind.peer_mac_addr);
Jong Wook Kimda830c92018-07-23 15:29:38 -07002256 std::vector<V1_2::NanDataPathChannelInfo> channelInfo;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002257 for (unsigned int i = 0; i < legacy_ind.num_channels; ++i) {
Jong Wook Kimda830c92018-07-23 15:29:38 -07002258 V1_2::NanDataPathChannelInfo hidl_struct;
Etan Cohenc7bd0f72017-12-26 11:52:44 -08002259 if (!convertLegacyNdpChannelInfoToHidl(legacy_ind.channel_info[i],
2260 &hidl_struct)) {
2261 return false;
2262 }
2263 channelInfo.push_back(hidl_struct);
2264 }
2265 hidl_ind->channelInfo = channelInfo;
2266 std::vector<uint32_t> ndpInstanceIds;
2267 for (unsigned int i = 0; i < legacy_ind.num_ndp_instances; ++i) {
2268 ndpInstanceIds.push_back(legacy_ind.ndp_instance_id[i]);
2269 }
2270 hidl_ind->ndpInstanceIds = ndpInstanceIds;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002271
Roshan Piusabcf78f2017-10-06 16:30:38 -07002272 return true;
Roshan Piusf5f51fd2016-12-01 13:54:24 -08002273}
Roshan Pius3fae9c82016-12-02 14:49:41 -08002274
2275legacy_hal::wifi_rtt_type convertHidlRttTypeToLegacy(RttType type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002276 switch (type) {
2277 case RttType::ONE_SIDED:
2278 return legacy_hal::RTT_TYPE_1_SIDED;
2279 case RttType::TWO_SIDED:
2280 return legacy_hal::RTT_TYPE_2_SIDED;
2281 };
2282 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002283}
2284
2285RttType convertLegacyRttTypeToHidl(legacy_hal::wifi_rtt_type type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002286 switch (type) {
2287 case legacy_hal::RTT_TYPE_1_SIDED:
2288 return RttType::ONE_SIDED;
2289 case legacy_hal::RTT_TYPE_2_SIDED:
2290 return RttType::TWO_SIDED;
2291 };
2292 CHECK(false) << "Unknown legacy type: " << type;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002293}
2294
2295legacy_hal::rtt_peer_type convertHidlRttPeerTypeToLegacy(RttPeerType type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002296 switch (type) {
2297 case RttPeerType::AP:
2298 return legacy_hal::RTT_PEER_AP;
2299 case RttPeerType::STA:
2300 return legacy_hal::RTT_PEER_STA;
2301 case RttPeerType::P2P_GO:
2302 return legacy_hal::RTT_PEER_P2P_GO;
2303 case RttPeerType::P2P_CLIENT:
2304 return legacy_hal::RTT_PEER_P2P_CLIENT;
2305 case RttPeerType::NAN:
2306 return legacy_hal::RTT_PEER_NAN;
2307 };
2308 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002309}
2310
2311legacy_hal::wifi_channel_width convertHidlWifiChannelWidthToLegacy(
2312 WifiChannelWidthInMhz type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002313 switch (type) {
2314 case WifiChannelWidthInMhz::WIDTH_20:
2315 return legacy_hal::WIFI_CHAN_WIDTH_20;
2316 case WifiChannelWidthInMhz::WIDTH_40:
2317 return legacy_hal::WIFI_CHAN_WIDTH_40;
2318 case WifiChannelWidthInMhz::WIDTH_80:
2319 return legacy_hal::WIFI_CHAN_WIDTH_80;
2320 case WifiChannelWidthInMhz::WIDTH_160:
2321 return legacy_hal::WIFI_CHAN_WIDTH_160;
2322 case WifiChannelWidthInMhz::WIDTH_80P80:
2323 return legacy_hal::WIFI_CHAN_WIDTH_80P80;
2324 case WifiChannelWidthInMhz::WIDTH_5:
2325 return legacy_hal::WIFI_CHAN_WIDTH_5;
2326 case WifiChannelWidthInMhz::WIDTH_10:
2327 return legacy_hal::WIFI_CHAN_WIDTH_10;
2328 case WifiChannelWidthInMhz::WIDTH_INVALID:
2329 return legacy_hal::WIFI_CHAN_WIDTH_INVALID;
2330 };
2331 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002332}
2333
2334WifiChannelWidthInMhz convertLegacyWifiChannelWidthToHidl(
2335 legacy_hal::wifi_channel_width type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002336 switch (type) {
2337 case legacy_hal::WIFI_CHAN_WIDTH_20:
2338 return WifiChannelWidthInMhz::WIDTH_20;
2339 case legacy_hal::WIFI_CHAN_WIDTH_40:
2340 return WifiChannelWidthInMhz::WIDTH_40;
2341 case legacy_hal::WIFI_CHAN_WIDTH_80:
2342 return WifiChannelWidthInMhz::WIDTH_80;
2343 case legacy_hal::WIFI_CHAN_WIDTH_160:
2344 return WifiChannelWidthInMhz::WIDTH_160;
2345 case legacy_hal::WIFI_CHAN_WIDTH_80P80:
2346 return WifiChannelWidthInMhz::WIDTH_80P80;
2347 case legacy_hal::WIFI_CHAN_WIDTH_5:
2348 return WifiChannelWidthInMhz::WIDTH_5;
2349 case legacy_hal::WIFI_CHAN_WIDTH_10:
2350 return WifiChannelWidthInMhz::WIDTH_10;
2351 case legacy_hal::WIFI_CHAN_WIDTH_INVALID:
2352 return WifiChannelWidthInMhz::WIDTH_INVALID;
2353 };
2354 CHECK(false) << "Unknown legacy type: " << type;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002355}
2356
Jimmy Chend460df32019-11-29 17:31:22 +02002357legacy_hal::wifi_rtt_preamble convertHidlRttPreambleToLegacy(
2358 V1_4::RttPreamble type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002359 switch (type) {
Jimmy Chend460df32019-11-29 17:31:22 +02002360 case V1_4::RttPreamble::LEGACY:
Roshan Piusabcf78f2017-10-06 16:30:38 -07002361 return legacy_hal::WIFI_RTT_PREAMBLE_LEGACY;
Jimmy Chend460df32019-11-29 17:31:22 +02002362 case V1_4::RttPreamble::HT:
Roshan Piusabcf78f2017-10-06 16:30:38 -07002363 return legacy_hal::WIFI_RTT_PREAMBLE_HT;
Jimmy Chend460df32019-11-29 17:31:22 +02002364 case V1_4::RttPreamble::VHT:
Roshan Piusabcf78f2017-10-06 16:30:38 -07002365 return legacy_hal::WIFI_RTT_PREAMBLE_VHT;
Jimmy Chend460df32019-11-29 17:31:22 +02002366 case V1_4::RttPreamble::HE:
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07002367 return legacy_hal::WIFI_RTT_PREAMBLE_HE;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002368 };
2369 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002370}
2371
Jimmy Chend460df32019-11-29 17:31:22 +02002372V1_4::RttPreamble convertLegacyRttPreambleToHidl(
2373 legacy_hal::wifi_rtt_preamble type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002374 switch (type) {
2375 case legacy_hal::WIFI_RTT_PREAMBLE_LEGACY:
Jimmy Chend460df32019-11-29 17:31:22 +02002376 return V1_4::RttPreamble::LEGACY;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002377 case legacy_hal::WIFI_RTT_PREAMBLE_HT:
Jimmy Chend460df32019-11-29 17:31:22 +02002378 return V1_4::RttPreamble::HT;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002379 case legacy_hal::WIFI_RTT_PREAMBLE_VHT:
Jimmy Chend460df32019-11-29 17:31:22 +02002380 return V1_4::RttPreamble::VHT;
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07002381 case legacy_hal::WIFI_RTT_PREAMBLE_HE:
Jimmy Chend460df32019-11-29 17:31:22 +02002382 return V1_4::RttPreamble::HE;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002383 };
2384 CHECK(false) << "Unknown legacy type: " << type;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002385}
2386
2387legacy_hal::wifi_rtt_bw convertHidlRttBwToLegacy(RttBw type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002388 switch (type) {
2389 case RttBw::BW_5MHZ:
2390 return legacy_hal::WIFI_RTT_BW_5;
2391 case RttBw::BW_10MHZ:
2392 return legacy_hal::WIFI_RTT_BW_10;
2393 case RttBw::BW_20MHZ:
2394 return legacy_hal::WIFI_RTT_BW_20;
2395 case RttBw::BW_40MHZ:
2396 return legacy_hal::WIFI_RTT_BW_40;
2397 case RttBw::BW_80MHZ:
2398 return legacy_hal::WIFI_RTT_BW_80;
2399 case RttBw::BW_160MHZ:
2400 return legacy_hal::WIFI_RTT_BW_160;
2401 };
2402 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002403}
2404
2405RttBw convertLegacyRttBwToHidl(legacy_hal::wifi_rtt_bw type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002406 switch (type) {
2407 case legacy_hal::WIFI_RTT_BW_5:
2408 return RttBw::BW_5MHZ;
2409 case legacy_hal::WIFI_RTT_BW_10:
2410 return RttBw::BW_10MHZ;
2411 case legacy_hal::WIFI_RTT_BW_20:
2412 return RttBw::BW_20MHZ;
2413 case legacy_hal::WIFI_RTT_BW_40:
2414 return RttBw::BW_40MHZ;
2415 case legacy_hal::WIFI_RTT_BW_80:
2416 return RttBw::BW_80MHZ;
2417 case legacy_hal::WIFI_RTT_BW_160:
2418 return RttBw::BW_160MHZ;
2419 };
2420 CHECK(false) << "Unknown legacy type: " << type;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002421}
2422
2423legacy_hal::wifi_motion_pattern convertHidlRttMotionPatternToLegacy(
2424 RttMotionPattern type) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002425 switch (type) {
2426 case RttMotionPattern::NOT_EXPECTED:
2427 return legacy_hal::WIFI_MOTION_NOT_EXPECTED;
2428 case RttMotionPattern::EXPECTED:
2429 return legacy_hal::WIFI_MOTION_EXPECTED;
2430 case RttMotionPattern::UNKNOWN:
2431 return legacy_hal::WIFI_MOTION_UNKNOWN;
2432 };
2433 CHECK(false);
Roshan Pius3fae9c82016-12-02 14:49:41 -08002434}
2435
Jimmy Chend460df32019-11-29 17:31:22 +02002436V1_4::WifiRatePreamble convertLegacyWifiRatePreambleToHidl(uint8_t preamble) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002437 switch (preamble) {
2438 case 0:
Jimmy Chend460df32019-11-29 17:31:22 +02002439 return V1_4::WifiRatePreamble::OFDM;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002440 case 1:
Jimmy Chend460df32019-11-29 17:31:22 +02002441 return V1_4::WifiRatePreamble::CCK;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002442 case 2:
Jimmy Chend460df32019-11-29 17:31:22 +02002443 return V1_4::WifiRatePreamble::HT;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002444 case 3:
Jimmy Chend460df32019-11-29 17:31:22 +02002445 return V1_4::WifiRatePreamble::VHT;
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07002446 case 4:
Jimmy Chend460df32019-11-29 17:31:22 +02002447 return V1_4::WifiRatePreamble::HE;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002448 default:
Jimmy Chend460df32019-11-29 17:31:22 +02002449 return V1_4::WifiRatePreamble::RESERVED;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002450 };
2451 CHECK(false) << "Unknown legacy preamble: " << preamble;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002452}
2453
2454WifiRateNss convertLegacyWifiRateNssToHidl(uint8_t nss) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002455 switch (nss) {
2456 case 0:
2457 return WifiRateNss::NSS_1x1;
2458 case 1:
2459 return WifiRateNss::NSS_2x2;
2460 case 2:
2461 return WifiRateNss::NSS_3x3;
2462 case 3:
2463 return WifiRateNss::NSS_4x4;
2464 };
2465 CHECK(false) << "Unknown legacy nss: " << nss;
2466 return {};
Roshan Pius3fae9c82016-12-02 14:49:41 -08002467}
2468
2469RttStatus convertLegacyRttStatusToHidl(legacy_hal::wifi_rtt_status status) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002470 switch (status) {
2471 case legacy_hal::RTT_STATUS_SUCCESS:
2472 return RttStatus::SUCCESS;
2473 case legacy_hal::RTT_STATUS_FAILURE:
2474 return RttStatus::FAILURE;
2475 case legacy_hal::RTT_STATUS_FAIL_NO_RSP:
2476 return RttStatus::FAIL_NO_RSP;
2477 case legacy_hal::RTT_STATUS_FAIL_REJECTED:
2478 return RttStatus::FAIL_REJECTED;
2479 case legacy_hal::RTT_STATUS_FAIL_NOT_SCHEDULED_YET:
2480 return RttStatus::FAIL_NOT_SCHEDULED_YET;
2481 case legacy_hal::RTT_STATUS_FAIL_TM_TIMEOUT:
2482 return RttStatus::FAIL_TM_TIMEOUT;
2483 case legacy_hal::RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL:
2484 return RttStatus::FAIL_AP_ON_DIFF_CHANNEL;
2485 case legacy_hal::RTT_STATUS_FAIL_NO_CAPABILITY:
2486 return RttStatus::FAIL_NO_CAPABILITY;
2487 case legacy_hal::RTT_STATUS_ABORTED:
2488 return RttStatus::ABORTED;
2489 case legacy_hal::RTT_STATUS_FAIL_INVALID_TS:
2490 return RttStatus::FAIL_INVALID_TS;
2491 case legacy_hal::RTT_STATUS_FAIL_PROTOCOL:
2492 return RttStatus::FAIL_PROTOCOL;
2493 case legacy_hal::RTT_STATUS_FAIL_SCHEDULE:
2494 return RttStatus::FAIL_SCHEDULE;
2495 case legacy_hal::RTT_STATUS_FAIL_BUSY_TRY_LATER:
2496 return RttStatus::FAIL_BUSY_TRY_LATER;
2497 case legacy_hal::RTT_STATUS_INVALID_REQ:
2498 return RttStatus::INVALID_REQ;
2499 case legacy_hal::RTT_STATUS_NO_WIFI:
2500 return RttStatus::NO_WIFI;
2501 case legacy_hal::RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE:
2502 return RttStatus::FAIL_FTM_PARAM_OVERRIDE;
Etan Cohen69c89222018-03-08 13:39:19 -08002503 case legacy_hal::RTT_STATUS_NAN_RANGING_PROTOCOL_FAILURE:
2504 return RttStatus::FAILURE; // TODO: add HIDL enumeration
2505 case legacy_hal::RTT_STATUS_NAN_RANGING_CONCURRENCY_NOT_SUPPORTED:
2506 return RttStatus::FAILURE; // TODO: add HIDL enumeration
Roshan Piusabcf78f2017-10-06 16:30:38 -07002507 };
2508 CHECK(false) << "Unknown legacy status: " << status;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002509}
2510
2511bool convertHidlWifiChannelInfoToLegacy(
2512 const WifiChannelInfo& hidl_info,
2513 legacy_hal::wifi_channel_info* legacy_info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002514 if (!legacy_info) {
2515 return false;
2516 }
2517 *legacy_info = {};
2518 legacy_info->width = convertHidlWifiChannelWidthToLegacy(hidl_info.width);
2519 legacy_info->center_freq = hidl_info.centerFreq;
2520 legacy_info->center_freq0 = hidl_info.centerFreq0;
2521 legacy_info->center_freq1 = hidl_info.centerFreq1;
2522 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002523}
2524
2525bool convertLegacyWifiChannelInfoToHidl(
2526 const legacy_hal::wifi_channel_info& legacy_info,
2527 WifiChannelInfo* hidl_info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002528 if (!hidl_info) {
2529 return false;
2530 }
2531 *hidl_info = {};
2532 hidl_info->width = convertLegacyWifiChannelWidthToHidl(legacy_info.width);
2533 hidl_info->centerFreq = legacy_info.center_freq;
2534 hidl_info->centerFreq0 = legacy_info.center_freq0;
2535 hidl_info->centerFreq1 = legacy_info.center_freq1;
2536 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002537}
2538
Jimmy Chend460df32019-11-29 17:31:22 +02002539bool convertHidlRttConfigToLegacy(const V1_4::RttConfig& hidl_config,
Roshan Pius3fae9c82016-12-02 14:49:41 -08002540 legacy_hal::wifi_rtt_config* legacy_config) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002541 if (!legacy_config) {
2542 return false;
2543 }
2544 *legacy_config = {};
2545 CHECK(hidl_config.addr.size() == sizeof(legacy_config->addr));
2546 memcpy(legacy_config->addr, hidl_config.addr.data(),
2547 hidl_config.addr.size());
2548 legacy_config->type = convertHidlRttTypeToLegacy(hidl_config.type);
2549 legacy_config->peer = convertHidlRttPeerTypeToLegacy(hidl_config.peer);
2550 if (!convertHidlWifiChannelInfoToLegacy(hidl_config.channel,
2551 &legacy_config->channel)) {
2552 return false;
2553 }
2554 legacy_config->burst_period = hidl_config.burstPeriod;
2555 legacy_config->num_burst = hidl_config.numBurst;
2556 legacy_config->num_frames_per_burst = hidl_config.numFramesPerBurst;
2557 legacy_config->num_retries_per_rtt_frame =
2558 hidl_config.numRetriesPerRttFrame;
2559 legacy_config->num_retries_per_ftmr = hidl_config.numRetriesPerFtmr;
2560 legacy_config->LCI_request = hidl_config.mustRequestLci;
2561 legacy_config->LCR_request = hidl_config.mustRequestLcr;
2562 legacy_config->burst_duration = hidl_config.burstDuration;
2563 legacy_config->preamble =
2564 convertHidlRttPreambleToLegacy(hidl_config.preamble);
2565 legacy_config->bw = convertHidlRttBwToLegacy(hidl_config.bw);
2566 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002567}
2568
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002569bool convertHidlVectorOfRttConfigToLegacy(
Jimmy Chend460df32019-11-29 17:31:22 +02002570 const std::vector<V1_4::RttConfig>& hidl_configs,
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002571 std::vector<legacy_hal::wifi_rtt_config>* legacy_configs) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002572 if (!legacy_configs) {
2573 return false;
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002574 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002575 *legacy_configs = {};
2576 for (const auto& hidl_config : hidl_configs) {
2577 legacy_hal::wifi_rtt_config legacy_config;
2578 if (!convertHidlRttConfigToLegacy(hidl_config, &legacy_config)) {
2579 return false;
2580 }
2581 legacy_configs->push_back(legacy_config);
2582 }
2583 return true;
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002584}
2585
Roshan Pius3fae9c82016-12-02 14:49:41 -08002586bool convertHidlRttLciInformationToLegacy(
2587 const RttLciInformation& hidl_info,
2588 legacy_hal::wifi_lci_information* legacy_info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002589 if (!legacy_info) {
2590 return false;
2591 }
2592 *legacy_info = {};
2593 legacy_info->latitude = hidl_info.latitude;
2594 legacy_info->longitude = hidl_info.longitude;
2595 legacy_info->altitude = hidl_info.altitude;
2596 legacy_info->latitude_unc = hidl_info.latitudeUnc;
2597 legacy_info->longitude_unc = hidl_info.longitudeUnc;
2598 legacy_info->altitude_unc = hidl_info.altitudeUnc;
2599 legacy_info->motion_pattern =
2600 convertHidlRttMotionPatternToLegacy(hidl_info.motionPattern);
2601 legacy_info->floor = hidl_info.floor;
2602 legacy_info->height_above_floor = hidl_info.heightAboveFloor;
2603 legacy_info->height_unc = hidl_info.heightUnc;
2604 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002605}
2606
2607bool convertHidlRttLcrInformationToLegacy(
2608 const RttLcrInformation& hidl_info,
2609 legacy_hal::wifi_lcr_information* legacy_info) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002610 if (!legacy_info) {
2611 return false;
2612 }
2613 *legacy_info = {};
2614 CHECK(hidl_info.countryCode.size() == sizeof(legacy_info->country_code));
2615 memcpy(legacy_info->country_code, hidl_info.countryCode.data(),
2616 hidl_info.countryCode.size());
2617 if (hidl_info.civicInfo.size() > sizeof(legacy_info->civic_info)) {
2618 return false;
2619 }
2620 legacy_info->length = hidl_info.civicInfo.size();
2621 memcpy(legacy_info->civic_info, hidl_info.civicInfo.c_str(),
2622 hidl_info.civicInfo.size());
2623 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002624}
2625
2626bool convertHidlRttResponderToLegacy(
Jimmy Chend460df32019-11-29 17:31:22 +02002627 const V1_4::RttResponder& hidl_responder,
Roshan Pius3fae9c82016-12-02 14:49:41 -08002628 legacy_hal::wifi_rtt_responder* legacy_responder) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002629 if (!legacy_responder) {
2630 return false;
2631 }
2632 *legacy_responder = {};
2633 if (!convertHidlWifiChannelInfoToLegacy(hidl_responder.channel,
2634 &legacy_responder->channel)) {
2635 return false;
2636 }
2637 legacy_responder->preamble =
2638 convertHidlRttPreambleToLegacy(hidl_responder.preamble);
2639 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002640}
2641
2642bool convertLegacyRttResponderToHidl(
2643 const legacy_hal::wifi_rtt_responder& legacy_responder,
Jimmy Chend460df32019-11-29 17:31:22 +02002644 V1_4::RttResponder* hidl_responder) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002645 if (!hidl_responder) {
2646 return false;
2647 }
2648 *hidl_responder = {};
2649 if (!convertLegacyWifiChannelInfoToHidl(legacy_responder.channel,
2650 &hidl_responder->channel)) {
2651 return false;
2652 }
2653 hidl_responder->preamble =
2654 convertLegacyRttPreambleToHidl(legacy_responder.preamble);
2655 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002656}
2657
2658bool convertLegacyRttCapabilitiesToHidl(
2659 const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
Jimmy Chend460df32019-11-29 17:31:22 +02002660 V1_4::RttCapabilities* hidl_capabilities) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002661 if (!hidl_capabilities) {
2662 return false;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002663 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002664 *hidl_capabilities = {};
2665 hidl_capabilities->rttOneSidedSupported =
2666 legacy_capabilities.rtt_one_sided_supported;
2667 hidl_capabilities->rttFtmSupported = legacy_capabilities.rtt_ftm_supported;
2668 hidl_capabilities->lciSupported = legacy_capabilities.lci_support;
2669 hidl_capabilities->lcrSupported = legacy_capabilities.lcr_support;
2670 hidl_capabilities->responderSupported =
2671 legacy_capabilities.responder_supported;
2672 hidl_capabilities->preambleSupport = 0;
Ahmed ElArabawyeeb53382019-10-10 20:18:31 -07002673 for (const auto flag :
2674 {legacy_hal::WIFI_RTT_PREAMBLE_LEGACY,
2675 legacy_hal::WIFI_RTT_PREAMBLE_HT, legacy_hal::WIFI_RTT_PREAMBLE_VHT,
2676 legacy_hal::WIFI_RTT_PREAMBLE_HE}) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002677 if (legacy_capabilities.preamble_support & flag) {
2678 hidl_capabilities->preambleSupport |=
Jimmy Chend460df32019-11-29 17:31:22 +02002679 static_cast<std::underlying_type<V1_4::RttPreamble>::type>(
Roshan Piusabcf78f2017-10-06 16:30:38 -07002680 convertLegacyRttPreambleToHidl(flag));
2681 }
Roshan Pius3fae9c82016-12-02 14:49:41 -08002682 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002683 hidl_capabilities->bwSupport = 0;
2684 for (const auto flag :
2685 {legacy_hal::WIFI_RTT_BW_5, legacy_hal::WIFI_RTT_BW_10,
2686 legacy_hal::WIFI_RTT_BW_20, legacy_hal::WIFI_RTT_BW_40,
2687 legacy_hal::WIFI_RTT_BW_80, legacy_hal::WIFI_RTT_BW_160}) {
2688 if (legacy_capabilities.bw_support & flag) {
2689 hidl_capabilities->bwSupport |=
2690 static_cast<std::underlying_type<RttBw>::type>(
2691 convertLegacyRttBwToHidl(flag));
2692 }
2693 }
2694 hidl_capabilities->mcVersion = legacy_capabilities.mc_version;
2695 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002696}
2697
2698bool convertLegacyWifiRateInfoToHidl(const legacy_hal::wifi_rate& legacy_rate,
Jimmy Chend460df32019-11-29 17:31:22 +02002699 V1_4::WifiRateInfo* hidl_rate) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002700 if (!hidl_rate) {
2701 return false;
2702 }
2703 *hidl_rate = {};
2704 hidl_rate->preamble =
2705 convertLegacyWifiRatePreambleToHidl(legacy_rate.preamble);
2706 hidl_rate->nss = convertLegacyWifiRateNssToHidl(legacy_rate.nss);
2707 hidl_rate->bw = convertLegacyWifiChannelWidthToHidl(
2708 static_cast<legacy_hal::wifi_channel_width>(legacy_rate.bw));
2709 hidl_rate->rateMcsIdx = legacy_rate.rateMcsIdx;
2710 hidl_rate->bitRateInKbps = legacy_rate.bitrate;
2711 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002712}
2713
2714bool convertLegacyRttResultToHidl(
Jimmy Chend460df32019-11-29 17:31:22 +02002715 const legacy_hal::wifi_rtt_result& legacy_result,
2716 V1_4::RttResult* hidl_result) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002717 if (!hidl_result) {
2718 return false;
2719 }
2720 *hidl_result = {};
2721 CHECK(sizeof(legacy_result.addr) == hidl_result->addr.size());
2722 memcpy(hidl_result->addr.data(), legacy_result.addr,
2723 sizeof(legacy_result.addr));
2724 hidl_result->burstNum = legacy_result.burst_num;
2725 hidl_result->measurementNumber = legacy_result.measurement_number;
2726 hidl_result->successNumber = legacy_result.success_number;
2727 hidl_result->numberPerBurstPeer = legacy_result.number_per_burst_peer;
2728 hidl_result->status = convertLegacyRttStatusToHidl(legacy_result.status);
2729 hidl_result->retryAfterDuration = legacy_result.retry_after_duration;
2730 hidl_result->type = convertLegacyRttTypeToHidl(legacy_result.type);
2731 hidl_result->rssi = legacy_result.rssi;
2732 hidl_result->rssiSpread = legacy_result.rssi_spread;
2733 if (!convertLegacyWifiRateInfoToHidl(legacy_result.tx_rate,
2734 &hidl_result->txRate)) {
2735 return false;
2736 }
2737 if (!convertLegacyWifiRateInfoToHidl(legacy_result.rx_rate,
2738 &hidl_result->rxRate)) {
2739 return false;
2740 }
2741 hidl_result->rtt = legacy_result.rtt;
2742 hidl_result->rttSd = legacy_result.rtt_sd;
2743 hidl_result->rttSpread = legacy_result.rtt_spread;
2744 hidl_result->distanceInMm = legacy_result.distance_mm;
2745 hidl_result->distanceSdInMm = legacy_result.distance_sd_mm;
2746 hidl_result->distanceSpreadInMm = legacy_result.distance_spread_mm;
2747 hidl_result->timeStampInUs = legacy_result.ts;
2748 hidl_result->burstDurationInMs = legacy_result.burst_duration;
2749 hidl_result->negotiatedBurstNum = legacy_result.negotiated_burst_num;
2750 if (legacy_result.LCI &&
2751 !convertLegacyIeToHidl(*legacy_result.LCI, &hidl_result->lci)) {
2752 return false;
2753 }
2754 if (legacy_result.LCR &&
2755 !convertLegacyIeToHidl(*legacy_result.LCR, &hidl_result->lcr)) {
2756 return false;
2757 }
2758 return true;
Roshan Pius3fae9c82016-12-02 14:49:41 -08002759}
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002760
2761bool convertLegacyVectorOfRttResultToHidl(
2762 const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
Jimmy Chend460df32019-11-29 17:31:22 +02002763 std::vector<V1_4::RttResult>* hidl_results) {
Roshan Piusabcf78f2017-10-06 16:30:38 -07002764 if (!hidl_results) {
2765 return false;
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002766 }
Roshan Piusabcf78f2017-10-06 16:30:38 -07002767 *hidl_results = {};
2768 for (const auto legacy_result : legacy_results) {
Jimmy Chend460df32019-11-29 17:31:22 +02002769 V1_4::RttResult hidl_result;
Roshan Piusabcf78f2017-10-06 16:30:38 -07002770 if (!convertLegacyRttResultToHidl(*legacy_result, &hidl_result)) {
2771 return false;
2772 }
2773 hidl_results->push_back(hidl_result);
2774 }
2775 return true;
Roshan Piuse3f72ff2016-12-05 16:18:43 -08002776}
Sunil Raviddab4bb2020-02-03 22:45:19 -08002777
2778legacy_hal::wifi_interface_type convertHidlIfaceTypeToLegacy(
2779 IfaceType hidl_interface_type) {
2780 switch (hidl_interface_type) {
2781 case IfaceType::STA:
2782 return legacy_hal::WIFI_INTERFACE_TYPE_STA;
2783 case IfaceType::AP:
2784 return legacy_hal::WIFI_INTERFACE_TYPE_AP;
2785 case IfaceType::P2P:
2786 return legacy_hal::WIFI_INTERFACE_TYPE_P2P;
2787 case IfaceType::NAN:
2788 return legacy_hal::WIFI_INTERFACE_TYPE_NAN;
2789 }
2790 CHECK(false);
2791}
Roshan Piuse9d1e7d2020-11-04 11:44:16 -08002792
2793legacy_hal::wifi_multi_sta_use_case convertHidlMultiStaUseCaseToLegacy(
2794 IWifiChip::MultiStaUseCase use_case) {
2795 switch (use_case) {
2796 case IWifiChip::MultiStaUseCase::DUAL_STA_TRANSIENT_PREFER_PRIMARY:
2797 return legacy_hal::WIFI_DUAL_STA_TRANSIENT_PREFER_PRIMARY;
2798 case IWifiChip::MultiStaUseCase::DUAL_STA_NON_TRANSIENT_UNBIASED:
2799 return legacy_hal::WIFI_DUAL_STA_NON_TRANSIENT_UNBIASED;
2800 }
2801 CHECK(false);
2802}
Roshan Piuse65edb12016-11-22 13:02:01 -08002803} // namespace hidl_struct_util
2804} // namespace implementation
Jimmy Chend460df32019-11-29 17:31:22 +02002805} // namespace V1_5
Roshan Piuse65edb12016-11-22 13:02:01 -08002806} // namespace wifi
2807} // namespace hardware
2808} // namespace android