Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 11:36:00 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
21a98b4a516a673be2e79579e1c1dc9dc35cc85e
hardware_interfaces/wifi/aidl/default/aidl_struct_util.cpp
Mahesh KKV 21a98b4a51 Rename maxMloLinkCount to maxMloStrLinkCount 
The maximum number of Simultaneous Transmit Receive (STR) links used in
Multi-Link Operation can be different from the maximum radios supported
by the chip.Explicitly mention the max links as max STR links. Update
the description and usage of the capability field.

Bug: 267963579
Test: m android.hardware.wifi-update-api
Change-Id: I5691fcc44c60821766fe41e67624e458ba051059
2023-02-06 04:38:26 +00:00

3343 lines
155 KiB
C++
Raw Blame History

/*
* Copyright (C) 2022 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <android-base/logging.h>
#include <utils/SystemClock.h>
#include "aidl_struct_util.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace aidl_struct_util {
WifiChannelWidthInMhz convertLegacyWifiChannelWidthToAidl(legacy_hal::wifi_channel_width type);
std::string safeConvertChar(const char* str, size_t max_len) {
const char* c = str;
size_t size = 0;
while (*c && (unsigned char)*c < 128 && size < max_len) {
++size;
++c;
}
return std::string(str, size);
}
inline std::vector<int32_t> uintToIntVec(const std::vector<uint32_t>& in) {
return std::vector<int32_t>(in.begin(), in.end());
}
IWifiChip::ChipCapabilityMask convertLegacyLoggerFeatureToAidlChipCapability(uint32_t feature) {
switch (feature) {
case legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED:
return IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_FIRMWARE_DUMP;
case legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED:
return IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_DRIVER_DUMP;
case legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED:
return IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_CONNECT_EVENT;
case legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED:
return IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_POWER_EVENT;
case legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED:
return IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_WAKELOCK_EVENT;
};
CHECK(false) << "Unknown legacy feature: " << feature;
return {};
}
IWifiStaIface::StaIfaceCapabilityMask convertLegacyLoggerFeatureToAidlStaIfaceCapability(
uint32_t feature) {
switch (feature) {
case legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED:
return IWifiStaIface::StaIfaceCapabilityMask::DEBUG_PACKET_FATE;
};
CHECK(false) << "Unknown legacy feature: " << feature;
return {};
}
IWifiChip::ChipCapabilityMask convertLegacyFeatureToAidlChipCapability(uint64_t feature) {
switch (feature) {
case WIFI_FEATURE_SET_TX_POWER_LIMIT:
return IWifiChip::ChipCapabilityMask::SET_TX_POWER_LIMIT;
case WIFI_FEATURE_USE_BODY_HEAD_SAR:
return IWifiChip::ChipCapabilityMask::USE_BODY_HEAD_SAR;
case WIFI_FEATURE_D2D_RTT:
return IWifiChip::ChipCapabilityMask::D2D_RTT;
case WIFI_FEATURE_D2AP_RTT:
return IWifiChip::ChipCapabilityMask::D2AP_RTT;
case WIFI_FEATURE_INFRA_60G:
return IWifiChip::ChipCapabilityMask::WIGIG;
case WIFI_FEATURE_SET_LATENCY_MODE:
return IWifiChip::ChipCapabilityMask::SET_LATENCY_MODE;
case WIFI_FEATURE_P2P_RAND_MAC:
return IWifiChip::ChipCapabilityMask::P2P_RAND_MAC;
case WIFI_FEATURE_AFC_CHANNEL:
return IWifiChip::ChipCapabilityMask::SET_AFC_CHANNEL_ALLOWANCE;
};
CHECK(false) << "Unknown legacy feature: " << feature;
return {};
}
IWifiStaIface::StaIfaceCapabilityMask convertLegacyFeatureToAidlStaIfaceCapability(
uint64_t feature) {
switch (feature) {
case WIFI_FEATURE_GSCAN:
return IWifiStaIface::StaIfaceCapabilityMask::BACKGROUND_SCAN;
case WIFI_FEATURE_LINK_LAYER_STATS:
return IWifiStaIface::StaIfaceCapabilityMask::LINK_LAYER_STATS;
case WIFI_FEATURE_RSSI_MONITOR:
return IWifiStaIface::StaIfaceCapabilityMask::RSSI_MONITOR;
case WIFI_FEATURE_CONTROL_ROAMING:
return IWifiStaIface::StaIfaceCapabilityMask::CONTROL_ROAMING;
case WIFI_FEATURE_IE_WHITELIST:
return IWifiStaIface::StaIfaceCapabilityMask::PROBE_IE_ALLOWLIST;
case WIFI_FEATURE_SCAN_RAND:
return IWifiStaIface::StaIfaceCapabilityMask::SCAN_RAND;
case WIFI_FEATURE_INFRA_5G:
return IWifiStaIface::StaIfaceCapabilityMask::STA_5G;
case WIFI_FEATURE_HOTSPOT:
return IWifiStaIface::StaIfaceCapabilityMask::HOTSPOT;
case WIFI_FEATURE_PNO:
return IWifiStaIface::StaIfaceCapabilityMask::PNO;
case WIFI_FEATURE_TDLS:
return IWifiStaIface::StaIfaceCapabilityMask::TDLS;
case WIFI_FEATURE_TDLS_OFFCHANNEL:
return IWifiStaIface::StaIfaceCapabilityMask::TDLS_OFFCHANNEL;
case WIFI_FEATURE_CONFIG_NDO:
return IWifiStaIface::StaIfaceCapabilityMask::ND_OFFLOAD;
case WIFI_FEATURE_MKEEP_ALIVE:
return IWifiStaIface::StaIfaceCapabilityMask::KEEP_ALIVE;
};
CHECK(false) << "Unknown legacy feature: " << feature;
return {};
}
bool convertLegacyFeaturesToAidlChipCapabilities(uint64_t legacy_feature_set,
uint32_t legacy_logger_feature_set,
uint32_t* aidl_caps) {
if (!aidl_caps) {
return false;
}
*aidl_caps = {};
for (const auto feature : {legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED,
legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED,
legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED,
legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED,
legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED}) {
if (feature & legacy_logger_feature_set) {
*aidl_caps |=
static_cast<uint32_t>(convertLegacyLoggerFeatureToAidlChipCapability(feature));
}
}
std::vector<uint64_t> features = {WIFI_FEATURE_SET_TX_POWER_LIMIT,
WIFI_FEATURE_USE_BODY_HEAD_SAR,
WIFI_FEATURE_D2D_RTT,
WIFI_FEATURE_D2AP_RTT,
WIFI_FEATURE_INFRA_60G,
WIFI_FEATURE_SET_LATENCY_MODE,
WIFI_FEATURE_P2P_RAND_MAC,
WIFI_FEATURE_AFC_CHANNEL};
for (const auto feature : features) {
if (feature & legacy_feature_set) {
*aidl_caps |= static_cast<uint32_t>(convertLegacyFeatureToAidlChipCapability(feature));
}
}
// There are no flags for these 3 in the legacy feature set. Adding them to
// the set because all the current devices support it.
*aidl_caps |=
static_cast<uint32_t>(IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_VENDOR_DATA);
*aidl_caps |=
static_cast<uint32_t>(IWifiChip::ChipCapabilityMask::DEBUG_HOST_WAKE_REASON_STATS);
*aidl_caps |= static_cast<uint32_t>(IWifiChip::ChipCapabilityMask::DEBUG_ERROR_ALERTS);
return true;
}
WifiDebugRingBufferFlags convertLegacyDebugRingBufferFlagsToAidl(uint32_t flag) {
switch (flag) {
case WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES:
return WifiDebugRingBufferFlags::HAS_BINARY_ENTRIES;
case WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES:
return WifiDebugRingBufferFlags::HAS_ASCII_ENTRIES;
};
CHECK(false) << "Unknown legacy flag: " << flag;
return {};
}
bool convertLegacyDebugRingBufferStatusToAidl(
const legacy_hal::wifi_ring_buffer_status& legacy_status,
WifiDebugRingBufferStatus* aidl_status) {
if (!aidl_status) {
return false;
}
*aidl_status = {};
aidl_status->ringName = safeConvertChar(reinterpret_cast<const char*>(legacy_status.name),
sizeof(legacy_status.name));
aidl_status->flags = 0;
for (const auto flag :
{WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES, WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES}) {
if (flag & legacy_status.flags) {
aidl_status->flags |= static_cast<std::underlying_type<WifiDebugRingBufferFlags>::type>(
convertLegacyDebugRingBufferFlagsToAidl(flag));
}
}
aidl_status->ringId = legacy_status.ring_id;
aidl_status->sizeInBytes = legacy_status.ring_buffer_byte_size;
// Calculate free size of the ring the buffer. We don't need to send the
// exact read/write pointers that were there in the legacy HAL interface.
if (legacy_status.written_bytes >= legacy_status.read_bytes) {
aidl_status->freeSizeInBytes = legacy_status.ring_buffer_byte_size -
(legacy_status.written_bytes - legacy_status.read_bytes);
} else {
aidl_status->freeSizeInBytes = legacy_status.read_bytes - legacy_status.written_bytes;
}
aidl_status->verboseLevel = legacy_status.verbose_level;
return true;
}
bool convertLegacyVectorOfDebugRingBufferStatusToAidl(
const std::vector<legacy_hal::wifi_ring_buffer_status>& legacy_status_vec,
std::vector<WifiDebugRingBufferStatus>* aidl_status_vec) {
if (!aidl_status_vec) {
return false;
}
*aidl_status_vec = {};
for (const auto& legacy_status : legacy_status_vec) {
WifiDebugRingBufferStatus aidl_status;
if (!convertLegacyDebugRingBufferStatusToAidl(legacy_status, &aidl_status)) {
return false;
}
aidl_status_vec->push_back(aidl_status);
}
return true;
}
bool convertLegacyWakeReasonStatsToAidl(const legacy_hal::WakeReasonStats& legacy_stats,
WifiDebugHostWakeReasonStats* aidl_stats) {
if (!aidl_stats) {
return false;
}
*aidl_stats = {};
aidl_stats->totalCmdEventWakeCnt = legacy_stats.wake_reason_cnt.total_cmd_event_wake;
aidl_stats->cmdEventWakeCntPerType = uintToIntVec(legacy_stats.cmd_event_wake_cnt);
aidl_stats->totalDriverFwLocalWakeCnt = legacy_stats.wake_reason_cnt.total_driver_fw_local_wake;
aidl_stats->driverFwLocalWakeCntPerType = uintToIntVec(legacy_stats.driver_fw_local_wake_cnt);
aidl_stats->totalRxPacketWakeCnt = legacy_stats.wake_reason_cnt.total_rx_data_wake;
aidl_stats->rxPktWakeDetails.rxUnicastCnt =
legacy_stats.wake_reason_cnt.rx_wake_details.rx_unicast_cnt;
aidl_stats->rxPktWakeDetails.rxMulticastCnt =
legacy_stats.wake_reason_cnt.rx_wake_details.rx_multicast_cnt;
aidl_stats->rxPktWakeDetails.rxBroadcastCnt =
legacy_stats.wake_reason_cnt.rx_wake_details.rx_broadcast_cnt;
aidl_stats->rxMulticastPkWakeDetails.ipv4RxMulticastAddrCnt =
legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info.ipv4_rx_multicast_addr_cnt;
aidl_stats->rxMulticastPkWakeDetails.ipv6RxMulticastAddrCnt =
legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info.ipv6_rx_multicast_addr_cnt;
aidl_stats->rxMulticastPkWakeDetails.otherRxMulticastAddrCnt =
legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info.other_rx_multicast_addr_cnt;
aidl_stats->rxIcmpPkWakeDetails.icmpPkt =
legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp_pkt;
aidl_stats->rxIcmpPkWakeDetails.icmp6Pkt =
legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_pkt;
aidl_stats->rxIcmpPkWakeDetails.icmp6Ra =
legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ra;
aidl_stats->rxIcmpPkWakeDetails.icmp6Na =
legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_na;
aidl_stats->rxIcmpPkWakeDetails.icmp6Ns =
legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ns;
return true;
}
legacy_hal::wifi_power_scenario convertAidlTxPowerScenarioToLegacy(
IWifiChip::TxPowerScenario aidl_scenario) {
switch (aidl_scenario) {
case IWifiChip::TxPowerScenario::VOICE_CALL:
return legacy_hal::WIFI_POWER_SCENARIO_VOICE_CALL;
case IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF:
return legacy_hal::WIFI_POWER_SCENARIO_ON_HEAD_CELL_OFF;
case IWifiChip::TxPowerScenario::ON_HEAD_CELL_ON:
return legacy_hal::WIFI_POWER_SCENARIO_ON_HEAD_CELL_ON;
case IWifiChip::TxPowerScenario::ON_BODY_CELL_OFF:
return legacy_hal::WIFI_POWER_SCENARIO_ON_BODY_CELL_OFF;
case IWifiChip::TxPowerScenario::ON_BODY_CELL_ON:
return legacy_hal::WIFI_POWER_SCENARIO_ON_BODY_CELL_ON;
};
CHECK(false);
}
legacy_hal::wifi_latency_mode convertAidlLatencyModeToLegacy(
IWifiChip::LatencyMode aidl_latency_mode) {
switch (aidl_latency_mode) {
case IWifiChip::LatencyMode::NORMAL:
return legacy_hal::WIFI_LATENCY_MODE_NORMAL;
case IWifiChip::LatencyMode::LOW:
return legacy_hal::WIFI_LATENCY_MODE_LOW;
}
CHECK(false);
}
bool convertLegacyWifiMacInfoToAidl(const legacy_hal::WifiMacInfo& legacy_mac_info,
IWifiChipEventCallback::RadioModeInfo* aidl_radio_mode_info) {
if (!aidl_radio_mode_info) {
return false;
}
*aidl_radio_mode_info = {};
aidl_radio_mode_info->radioId = legacy_mac_info.wlan_mac_id;
// Convert from bitmask of bands in the legacy HAL to enum value in
// the AIDL interface.
if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND &&
legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND &&
legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND) {
aidl_radio_mode_info->bandInfo = WifiBand::BAND_24GHZ_5GHZ_6GHZ;
} else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND &&
legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
aidl_radio_mode_info->bandInfo = WifiBand::BAND_5GHZ_6GHZ;
} else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_6_0_BAND) {
aidl_radio_mode_info->bandInfo = WifiBand::BAND_6GHZ;
} else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND &&
legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
aidl_radio_mode_info->bandInfo = WifiBand::BAND_24GHZ_5GHZ;
} else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_2_4_BAND) {
aidl_radio_mode_info->bandInfo = WifiBand::BAND_24GHZ;
} else if (legacy_mac_info.mac_band & legacy_hal::WLAN_MAC_5_0_BAND) {
aidl_radio_mode_info->bandInfo = WifiBand::BAND_5GHZ;
} else {
aidl_radio_mode_info->bandInfo = WifiBand::BAND_UNSPECIFIED;
}
std::vector<IWifiChipEventCallback::IfaceInfo> iface_info_vec;
for (const auto& legacy_iface_info : legacy_mac_info.iface_infos) {
IWifiChipEventCallback::IfaceInfo iface_info;
iface_info.name = legacy_iface_info.name;
iface_info.channel = legacy_iface_info.channel;
iface_info_vec.push_back(iface_info);
}
aidl_radio_mode_info->ifaceInfos = iface_info_vec;
return true;
}
uint32_t convertAidlWifiBandToLegacyMacBand(WifiBand aidl_band) {
switch (aidl_band) {
case WifiBand::BAND_24GHZ:
return legacy_hal::WLAN_MAC_2_4_BAND;
case WifiBand::BAND_5GHZ:
case WifiBand::BAND_5GHZ_DFS:
case WifiBand::BAND_5GHZ_WITH_DFS:
return legacy_hal::WLAN_MAC_5_0_BAND;
case WifiBand::BAND_24GHZ_5GHZ:
case WifiBand::BAND_24GHZ_5GHZ_WITH_DFS:
return (legacy_hal::WLAN_MAC_2_4_BAND | legacy_hal::WLAN_MAC_5_0_BAND);
case WifiBand::BAND_6GHZ:
return legacy_hal::WLAN_MAC_6_0_BAND;
case WifiBand::BAND_5GHZ_6GHZ:
return (legacy_hal::WLAN_MAC_5_0_BAND | legacy_hal::WLAN_MAC_6_0_BAND);
case WifiBand::BAND_24GHZ_5GHZ_6GHZ:
case WifiBand::BAND_24GHZ_5GHZ_WITH_DFS_6GHZ:
return (legacy_hal::WLAN_MAC_2_4_BAND | legacy_hal::WLAN_MAC_5_0_BAND |
legacy_hal::WLAN_MAC_6_0_BAND);
case WifiBand::BAND_60GHZ:
return legacy_hal::WLAN_MAC_60_0_BAND;
default:
return (legacy_hal::WLAN_MAC_2_4_BAND | legacy_hal::WLAN_MAC_5_0_BAND |
legacy_hal::WLAN_MAC_6_0_BAND | legacy_hal::WLAN_MAC_60_0_BAND);
}
}
WifiBand convertLegacyMacBandToAidlWifiBand(uint32_t band) {
switch (band) {
case legacy_hal::WLAN_MAC_2_4_BAND:
return WifiBand::BAND_24GHZ;
case legacy_hal::WLAN_MAC_5_0_BAND:
return WifiBand::BAND_5GHZ;
case legacy_hal::WLAN_MAC_6_0_BAND:
return WifiBand::BAND_6GHZ;
case legacy_hal::WLAN_MAC_60_0_BAND:
return WifiBand::BAND_60GHZ;
default:
return WifiBand::BAND_UNSPECIFIED;
}
}
uint32_t convertAidlWifiIfaceModeToLegacy(uint32_t aidl_iface_mask) {
uint32_t legacy_iface_mask = 0;
if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_STA)) {
legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_STA);
}
if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_SOFTAP)) {
legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_SOFTAP);
}
if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_P2P_CLIENT)) {
legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_P2P_CLIENT);
}
if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_P2P_GO)) {
legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_P2P_GO);
}
if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_NAN)) {
legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_NAN);
}
if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_TDLS)) {
legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_TDLS);
}
if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_MESH)) {
legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_MESH);
}
if (aidl_iface_mask & static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_IBSS)) {
legacy_iface_mask |= (1 << legacy_hal::WIFI_INTERFACE_IBSS);
}
return legacy_iface_mask;
}
uint32_t convertLegacyWifiInterfaceModeToAidl(uint32_t legacy_iface_mask) {
uint32_t aidl_iface_mask = 0;
if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_STA)) {
aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_STA);
}
if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_SOFTAP)) {
aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_SOFTAP);
}
if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_P2P_CLIENT)) {
aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_P2P_CLIENT);
}
if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_P2P_GO)) {
aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_P2P_GO);
}
if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_NAN)) {
aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_NAN);
}
if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_TDLS)) {
aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_TDLS);
}
if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_MESH)) {
aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_MESH);
}
if (legacy_iface_mask & (1 << legacy_hal::WIFI_INTERFACE_IBSS)) {
aidl_iface_mask |= static_cast<int32_t>(WifiIfaceMode::IFACE_MODE_IBSS);
}
return aidl_iface_mask;
}
uint32_t convertAidlUsableChannelFilterToLegacy(uint32_t aidl_filter_mask) {
uint32_t legacy_filter_mask = 0;
if (aidl_filter_mask &
static_cast<int32_t>(IWifiChip::UsableChannelFilter::CELLULAR_COEXISTENCE)) {
legacy_filter_mask |= legacy_hal::WIFI_USABLE_CHANNEL_FILTER_CELLULAR_COEXISTENCE;
}
if (aidl_filter_mask & static_cast<int32_t>(IWifiChip::UsableChannelFilter::CONCURRENCY)) {
legacy_filter_mask |= legacy_hal::WIFI_USABLE_CHANNEL_FILTER_CONCURRENCY;
}
if (aidl_filter_mask & static_cast<int32_t>(IWifiChip::UsableChannelFilter::NAN_INSTANT_MODE)) {
legacy_filter_mask |= WIFI_USABLE_CHANNEL_FILTER_NAN_INSTANT_MODE;
}
return legacy_filter_mask;
}
bool convertLegacyWifiUsableChannelToAidl(
const legacy_hal::wifi_usable_channel& legacy_usable_channel,
WifiUsableChannel* aidl_usable_channel) {
if (!aidl_usable_channel) {
return false;
}
*aidl_usable_channel = {};
aidl_usable_channel->channel = legacy_usable_channel.freq;
aidl_usable_channel->channelBandwidth =
convertLegacyWifiChannelWidthToAidl(legacy_usable_channel.width);
aidl_usable_channel->ifaceModeMask = static_cast<WifiIfaceMode>(
convertLegacyWifiInterfaceModeToAidl(legacy_usable_channel.iface_mode_mask));
return true;
}
bool convertLegacyWifiUsableChannelsToAidl(
const std::vector<legacy_hal::wifi_usable_channel>& legacy_usable_channels,
std::vector<WifiUsableChannel>* aidl_usable_channels) {
if (!aidl_usable_channels) {
return false;
}
*aidl_usable_channels = {};
for (const auto& legacy_usable_channel : legacy_usable_channels) {
WifiUsableChannel aidl_usable_channel;
if (!convertLegacyWifiUsableChannelToAidl(legacy_usable_channel, &aidl_usable_channel)) {
return false;
}
aidl_usable_channels->push_back(aidl_usable_channel);
}
return true;
}
bool convertLegacyWifiMacInfosToAidl(
const std::vector<legacy_hal::WifiMacInfo>& legacy_mac_infos,
std::vector<IWifiChipEventCallback::RadioModeInfo>* aidl_radio_mode_infos) {
if (!aidl_radio_mode_infos) {
return false;
}
*aidl_radio_mode_infos = {};
for (const auto& legacy_mac_info : legacy_mac_infos) {
IWifiChipEventCallback::RadioModeInfo aidl_radio_mode_info;
if (!convertLegacyWifiMacInfoToAidl(legacy_mac_info, &aidl_radio_mode_info)) {
return false;
}
aidl_radio_mode_infos->push_back(aidl_radio_mode_info);
}
return true;
}
bool convertLegacyFeaturesToAidlStaCapabilities(uint64_t legacy_feature_set,
uint32_t legacy_logger_feature_set,
uint32_t* aidl_caps) {
if (!aidl_caps) {
return false;
}
*aidl_caps = {};
for (const auto feature : {legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED}) {
if (feature & legacy_logger_feature_set) {
*aidl_caps |= static_cast<uint32_t>(
convertLegacyLoggerFeatureToAidlStaIfaceCapability(feature));
}
}
for (const auto feature :
{WIFI_FEATURE_GSCAN, WIFI_FEATURE_LINK_LAYER_STATS, WIFI_FEATURE_RSSI_MONITOR,
WIFI_FEATURE_CONTROL_ROAMING, WIFI_FEATURE_IE_WHITELIST, WIFI_FEATURE_SCAN_RAND,
WIFI_FEATURE_INFRA_5G, WIFI_FEATURE_HOTSPOT, WIFI_FEATURE_PNO, WIFI_FEATURE_TDLS,
WIFI_FEATURE_TDLS_OFFCHANNEL, WIFI_FEATURE_CONFIG_NDO, WIFI_FEATURE_MKEEP_ALIVE}) {
if (feature & legacy_feature_set) {
*aidl_caps |=
static_cast<uint32_t>(convertLegacyFeatureToAidlStaIfaceCapability(feature));
}
}
// There is no flag for this one in the legacy feature set. Adding it to the
// set because all the current devices support it.
*aidl_caps |= static_cast<uint32_t>(IWifiStaIface::StaIfaceCapabilityMask::APF);
return true;
}
bool convertLegacyApfCapabilitiesToAidl(const legacy_hal::PacketFilterCapabilities& legacy_caps,
StaApfPacketFilterCapabilities* aidl_caps) {
if (!aidl_caps) {
return false;
}
*aidl_caps = {};
aidl_caps->version = legacy_caps.version;
aidl_caps->maxLength = legacy_caps.max_len;
return true;
}
uint8_t convertAidlGscanReportEventFlagToLegacy(
StaBackgroundScanBucketEventReportSchemeMask aidl_flag) {
using AidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
switch (aidl_flag) {
case AidlFlag::EACH_SCAN:
return REPORT_EVENTS_EACH_SCAN;
case AidlFlag::FULL_RESULTS:
return REPORT_EVENTS_FULL_RESULTS;
case AidlFlag::NO_BATCH:
return REPORT_EVENTS_NO_BATCH;
};
CHECK(false);
}
StaScanDataFlagMask convertLegacyGscanDataFlagToAidl(uint8_t legacy_flag) {
switch (legacy_flag) {
case legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED:
return StaScanDataFlagMask::INTERRUPTED;
};
CHECK(false) << "Unknown legacy flag: " << legacy_flag;
// To silence the compiler warning about reaching the end of non-void
// function.
return {};
}
bool convertLegacyGscanCapabilitiesToAidl(const legacy_hal::wifi_gscan_capabilities& legacy_caps,
StaBackgroundScanCapabilities* aidl_caps) {
if (!aidl_caps) {
return false;
}
*aidl_caps = {};
aidl_caps->maxCacheSize = legacy_caps.max_scan_cache_size;
aidl_caps->maxBuckets = legacy_caps.max_scan_buckets;
aidl_caps->maxApCachePerScan = legacy_caps.max_ap_cache_per_scan;
aidl_caps->maxReportingThreshold = legacy_caps.max_scan_reporting_threshold;
return true;
}
legacy_hal::wifi_band convertAidlWifiBandToLegacy(WifiBand band) {
switch (band) {
case WifiBand::BAND_UNSPECIFIED:
return legacy_hal::WIFI_BAND_UNSPECIFIED;
case WifiBand::BAND_24GHZ:
return legacy_hal::WIFI_BAND_BG;
case WifiBand::BAND_5GHZ:
return legacy_hal::WIFI_BAND_A;
case WifiBand::BAND_5GHZ_DFS:
return legacy_hal::WIFI_BAND_A_DFS;
case WifiBand::BAND_5GHZ_WITH_DFS:
return legacy_hal::WIFI_BAND_A_WITH_DFS;
case WifiBand::BAND_24GHZ_5GHZ:
return legacy_hal::WIFI_BAND_ABG;
case WifiBand::BAND_24GHZ_5GHZ_WITH_DFS:
return legacy_hal::WIFI_BAND_ABG_WITH_DFS;
default:
CHECK(false);
return {};
};
}
bool convertAidlGscanParamsToLegacy(const StaBackgroundScanParameters& aidl_scan_params,
legacy_hal::wifi_scan_cmd_params* legacy_scan_params) {
if (!legacy_scan_params) {
return false;
}
*legacy_scan_params = {};
legacy_scan_params->base_period = aidl_scan_params.basePeriodInMs;
legacy_scan_params->max_ap_per_scan = aidl_scan_params.maxApPerScan;
legacy_scan_params->report_threshold_percent = aidl_scan_params.reportThresholdPercent;
legacy_scan_params->report_threshold_num_scans = aidl_scan_params.reportThresholdNumScans;
if (aidl_scan_params.buckets.size() > MAX_BUCKETS) {
return false;
}
legacy_scan_params->num_buckets = aidl_scan_params.buckets.size();
for (uint32_t bucket_idx = 0; bucket_idx < aidl_scan_params.buckets.size(); bucket_idx++) {
const StaBackgroundScanBucketParameters& aidl_bucket_spec =
aidl_scan_params.buckets[bucket_idx];
legacy_hal::wifi_scan_bucket_spec& legacy_bucket_spec =
legacy_scan_params->buckets[bucket_idx];
if (aidl_bucket_spec.bucketIdx >= MAX_BUCKETS) {
return false;
}
legacy_bucket_spec.bucket = aidl_bucket_spec.bucketIdx;
legacy_bucket_spec.band = convertAidlWifiBandToLegacy(aidl_bucket_spec.band);
legacy_bucket_spec.period = aidl_bucket_spec.periodInMs;
legacy_bucket_spec.max_period = aidl_bucket_spec.exponentialMaxPeriodInMs;
legacy_bucket_spec.base = aidl_bucket_spec.exponentialBase;
legacy_bucket_spec.step_count = aidl_bucket_spec.exponentialStepCount;
legacy_bucket_spec.report_events = 0;
using AidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
for (const auto flag : {AidlFlag::EACH_SCAN, AidlFlag::FULL_RESULTS, AidlFlag::NO_BATCH}) {
if (static_cast<int32_t>(aidl_bucket_spec.eventReportScheme) &
static_cast<std::underlying_type<AidlFlag>::type>(flag)) {
legacy_bucket_spec.report_events |= convertAidlGscanReportEventFlagToLegacy(flag);
}
}
if (aidl_bucket_spec.frequencies.size() > MAX_CHANNELS) {
return false;
}
legacy_bucket_spec.num_channels = aidl_bucket_spec.frequencies.size();
for (uint32_t freq_idx = 0; freq_idx < aidl_bucket_spec.frequencies.size(); freq_idx++) {
legacy_bucket_spec.channels[freq_idx].channel = aidl_bucket_spec.frequencies[freq_idx];
}
}
return true;
}
bool convertLegacyIeToAidl(const legacy_hal::wifi_information_element& legacy_ie,
WifiInformationElement* aidl_ie) {
if (!aidl_ie) {
return false;
}
*aidl_ie = {};
aidl_ie->id = legacy_ie.id;
aidl_ie->data = std::vector<uint8_t>(legacy_ie.data, legacy_ie.data + legacy_ie.len);
return true;
}
bool convertLegacyIeBlobToAidl(const uint8_t* ie_blob, uint32_t ie_blob_len,
std::vector<WifiInformationElement>* aidl_ies) {
if (!ie_blob || !aidl_ies) {
return false;
}
*aidl_ies = {};
const uint8_t* ies_begin = ie_blob;
const uint8_t* ies_end = ie_blob + ie_blob_len;
const uint8_t* next_ie = ies_begin;
using wifi_ie = legacy_hal::wifi_information_element;
constexpr size_t kIeHeaderLen = sizeof(wifi_ie);
// Each IE should at least have the header (i.e |id| & |len| fields).
while (next_ie + kIeHeaderLen <= ies_end) {
const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie));
uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len;
if (next_ie + curr_ie_len > ies_end) {
LOG(ERROR) << "Error parsing IE blob. Next IE: " << (void*)next_ie
<< ", Curr IE len: " << curr_ie_len << ", IEs End: " << (void*)ies_end;
break;
}
WifiInformationElement aidl_ie;
if (!convertLegacyIeToAidl(legacy_ie, &aidl_ie)) {
LOG(ERROR) << "Error converting IE. Id: " << legacy_ie.id << ", len: " << legacy_ie.len;
break;
}
aidl_ies->push_back(std::move(aidl_ie));
next_ie += curr_ie_len;
}
// Check if the blob has been fully consumed.
if (next_ie != ies_end) {
LOG(ERROR) << "Failed to fully parse IE blob. Next IE: " << (void*)next_ie
<< ", IEs End: " << (void*)ies_end;
}
return true;
}
bool convertLegacyGscanResultToAidl(const legacy_hal::wifi_scan_result& legacy_scan_result,
bool has_ie_data, StaScanResult* aidl_scan_result) {
if (!aidl_scan_result) {
return false;
}
*aidl_scan_result = {};
aidl_scan_result->timeStampInUs = legacy_scan_result.ts;
aidl_scan_result->ssid = std::vector<uint8_t>(
legacy_scan_result.ssid,
legacy_scan_result.ssid +
strnlen(legacy_scan_result.ssid, sizeof(legacy_scan_result.ssid) - 1));
aidl_scan_result->bssid = std::array<uint8_t, 6>();
std::copy(legacy_scan_result.bssid, legacy_scan_result.bssid + 6,
std::begin(aidl_scan_result->bssid));
aidl_scan_result->frequency = legacy_scan_result.channel;
aidl_scan_result->rssi = legacy_scan_result.rssi;
aidl_scan_result->beaconPeriodInMs = legacy_scan_result.beacon_period;
aidl_scan_result->capability = legacy_scan_result.capability;
if (has_ie_data) {
std::vector<WifiInformationElement> ies;
if (!convertLegacyIeBlobToAidl(reinterpret_cast<const uint8_t*>(legacy_scan_result.ie_data),
legacy_scan_result.ie_length, &ies)) {
return false;
}
aidl_scan_result->informationElements = std::move(ies);
}
return true;
}
bool convertLegacyCachedGscanResultsToAidl(
const legacy_hal::wifi_cached_scan_results& legacy_cached_scan_result,
StaScanData* aidl_scan_data) {
if (!aidl_scan_data) {
return false;
}
*aidl_scan_data = {};
int32_t flags = 0;
for (const auto flag : {legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED}) {
if (legacy_cached_scan_result.flags & flag) {
flags |= static_cast<std::underlying_type<StaScanDataFlagMask>::type>(
convertLegacyGscanDataFlagToAidl(flag));
}
}
aidl_scan_data->flags = static_cast<StaScanDataFlagMask>(flags);
aidl_scan_data->bucketsScanned = legacy_cached_scan_result.buckets_scanned;
CHECK(legacy_cached_scan_result.num_results >= 0 &&
legacy_cached_scan_result.num_results <= MAX_AP_CACHE_PER_SCAN);
std::vector<StaScanResult> aidl_scan_results;
for (int32_t result_idx = 0; result_idx < legacy_cached_scan_result.num_results; result_idx++) {
StaScanResult aidl_scan_result;
if (!convertLegacyGscanResultToAidl(legacy_cached_scan_result.results[result_idx], false,
&aidl_scan_result)) {
return false;
}
aidl_scan_results.push_back(aidl_scan_result);
}
aidl_scan_data->results = std::move(aidl_scan_results);
return true;
}
bool convertLegacyVectorOfCachedGscanResultsToAidl(
const std::vector<legacy_hal::wifi_cached_scan_results>& legacy_cached_scan_results,
std::vector<StaScanData>* aidl_scan_datas) {
if (!aidl_scan_datas) {
return false;
}
*aidl_scan_datas = {};
for (const auto& legacy_cached_scan_result : legacy_cached_scan_results) {
StaScanData aidl_scan_data;
if (!convertLegacyCachedGscanResultsToAidl(legacy_cached_scan_result, &aidl_scan_data)) {
return false;
}
aidl_scan_datas->push_back(aidl_scan_data);
}
return true;
}
WifiDebugTxPacketFate convertLegacyDebugTxPacketFateToAidl(legacy_hal::wifi_tx_packet_fate fate) {
switch (fate) {
case legacy_hal::TX_PKT_FATE_ACKED:
return WifiDebugTxPacketFate::ACKED;
case legacy_hal::TX_PKT_FATE_SENT:
return WifiDebugTxPacketFate::SENT;
case legacy_hal::TX_PKT_FATE_FW_QUEUED:
return WifiDebugTxPacketFate::FW_QUEUED;
case legacy_hal::TX_PKT_FATE_FW_DROP_INVALID:
return WifiDebugTxPacketFate::FW_DROP_INVALID;
case legacy_hal::TX_PKT_FATE_FW_DROP_NOBUFS:
return WifiDebugTxPacketFate::FW_DROP_NOBUFS;
case legacy_hal::TX_PKT_FATE_FW_DROP_OTHER:
return WifiDebugTxPacketFate::FW_DROP_OTHER;
case legacy_hal::TX_PKT_FATE_DRV_QUEUED:
return WifiDebugTxPacketFate::DRV_QUEUED;
case legacy_hal::TX_PKT_FATE_DRV_DROP_INVALID:
return WifiDebugTxPacketFate::DRV_DROP_INVALID;
case legacy_hal::TX_PKT_FATE_DRV_DROP_NOBUFS:
return WifiDebugTxPacketFate::DRV_DROP_NOBUFS;
case legacy_hal::TX_PKT_FATE_DRV_DROP_OTHER:
return WifiDebugTxPacketFate::DRV_DROP_OTHER;
};
CHECK(false) << "Unknown legacy fate type: " << fate;
}
WifiDebugRxPacketFate convertLegacyDebugRxPacketFateToAidl(legacy_hal::wifi_rx_packet_fate fate) {
switch (fate) {
case legacy_hal::RX_PKT_FATE_SUCCESS:
return WifiDebugRxPacketFate::SUCCESS;
case legacy_hal::RX_PKT_FATE_FW_QUEUED:
return WifiDebugRxPacketFate::FW_QUEUED;
case legacy_hal::RX_PKT_FATE_FW_DROP_FILTER:
return WifiDebugRxPacketFate::FW_DROP_FILTER;
case legacy_hal::RX_PKT_FATE_FW_DROP_INVALID:
return WifiDebugRxPacketFate::FW_DROP_INVALID;
case legacy_hal::RX_PKT_FATE_FW_DROP_NOBUFS:
return WifiDebugRxPacketFate::FW_DROP_NOBUFS;
case legacy_hal::RX_PKT_FATE_FW_DROP_OTHER:
return WifiDebugRxPacketFate::FW_DROP_OTHER;
case legacy_hal::RX_PKT_FATE_DRV_QUEUED:
return WifiDebugRxPacketFate::DRV_QUEUED;
case legacy_hal::RX_PKT_FATE_DRV_DROP_FILTER:
return WifiDebugRxPacketFate::DRV_DROP_FILTER;
case legacy_hal::RX_PKT_FATE_DRV_DROP_INVALID:
return WifiDebugRxPacketFate::DRV_DROP_INVALID;
case legacy_hal::RX_PKT_FATE_DRV_DROP_NOBUFS:
return WifiDebugRxPacketFate::DRV_DROP_NOBUFS;
case legacy_hal::RX_PKT_FATE_DRV_DROP_OTHER:
return WifiDebugRxPacketFate::DRV_DROP_OTHER;
};
CHECK(false) << "Unknown legacy fate type: " << fate;
}
WifiDebugPacketFateFrameType convertLegacyDebugPacketFateFrameTypeToAidl(
legacy_hal::frame_type type) {
switch (type) {
case legacy_hal::FRAME_TYPE_UNKNOWN:
return WifiDebugPacketFateFrameType::UNKNOWN;
case legacy_hal::FRAME_TYPE_ETHERNET_II:
return WifiDebugPacketFateFrameType::ETHERNET_II;
case legacy_hal::FRAME_TYPE_80211_MGMT:
return WifiDebugPacketFateFrameType::MGMT_80211;
};
CHECK(false) << "Unknown legacy frame type: " << type;
}
bool convertLegacyDebugPacketFateFrameToAidl(const legacy_hal::frame_info& legacy_frame,
WifiDebugPacketFateFrameInfo* aidl_frame) {
if (!aidl_frame) {
return false;
}
*aidl_frame = {};
aidl_frame->frameType = convertLegacyDebugPacketFateFrameTypeToAidl(legacy_frame.payload_type);
aidl_frame->frameLen = legacy_frame.frame_len;
aidl_frame->driverTimestampUsec = legacy_frame.driver_timestamp_usec;
aidl_frame->firmwareTimestampUsec = legacy_frame.firmware_timestamp_usec;
const uint8_t* frame_begin =
reinterpret_cast<const uint8_t*>(legacy_frame.frame_content.ethernet_ii_bytes);
aidl_frame->frameContent =
std::vector<uint8_t>(frame_begin, frame_begin + legacy_frame.frame_len);
return true;
}
bool convertLegacyDebugTxPacketFateToAidl(const legacy_hal::wifi_tx_report& legacy_fate,
WifiDebugTxPacketFateReport* aidl_fate) {
if (!aidl_fate) {
return false;
}
*aidl_fate = {};
aidl_fate->fate = convertLegacyDebugTxPacketFateToAidl(legacy_fate.fate);
return convertLegacyDebugPacketFateFrameToAidl(legacy_fate.frame_inf, &aidl_fate->frameInfo);
}
bool convertLegacyVectorOfDebugTxPacketFateToAidl(
const std::vector<legacy_hal::wifi_tx_report>& legacy_fates,
std::vector<WifiDebugTxPacketFateReport>* aidl_fates) {
if (!aidl_fates) {
return false;
}
*aidl_fates = {};
for (const auto& legacy_fate : legacy_fates) {
WifiDebugTxPacketFateReport aidl_fate;
if (!convertLegacyDebugTxPacketFateToAidl(legacy_fate, &aidl_fate)) {
return false;
}
aidl_fates->push_back(aidl_fate);
}
return true;
}
bool convertLegacyDebugRxPacketFateToAidl(const legacy_hal::wifi_rx_report& legacy_fate,
WifiDebugRxPacketFateReport* aidl_fate) {
if (!aidl_fate) {
return false;
}
*aidl_fate = {};
aidl_fate->fate = convertLegacyDebugRxPacketFateToAidl(legacy_fate.fate);
return convertLegacyDebugPacketFateFrameToAidl(legacy_fate.frame_inf, &aidl_fate->frameInfo);
}
bool convertLegacyVectorOfDebugRxPacketFateToAidl(
const std::vector<legacy_hal::wifi_rx_report>& legacy_fates,
std::vector<WifiDebugRxPacketFateReport>* aidl_fates) {
if (!aidl_fates) {
return false;
}
*aidl_fates = {};
for (const auto& legacy_fate : legacy_fates) {
WifiDebugRxPacketFateReport aidl_fate;
if (!convertLegacyDebugRxPacketFateToAidl(legacy_fate, &aidl_fate)) {
return false;
}
aidl_fates->push_back(aidl_fate);
}
return true;
}
bool convertLegacyLinkLayerRadioStatsToAidl(
const legacy_hal::LinkLayerRadioStats& legacy_radio_stat,
StaLinkLayerRadioStats* aidl_radio_stat) {
if (!aidl_radio_stat) {
return false;
}
*aidl_radio_stat = {};
aidl_radio_stat->radioId = legacy_radio_stat.stats.radio;
aidl_radio_stat->onTimeInMs = legacy_radio_stat.stats.on_time;
aidl_radio_stat->txTimeInMs = legacy_radio_stat.stats.tx_time;
aidl_radio_stat->rxTimeInMs = legacy_radio_stat.stats.rx_time;
aidl_radio_stat->onTimeInMsForScan = legacy_radio_stat.stats.on_time_scan;
aidl_radio_stat->txTimeInMsPerLevel = uintToIntVec(legacy_radio_stat.tx_time_per_levels);
aidl_radio_stat->onTimeInMsForNanScan = legacy_radio_stat.stats.on_time_nbd;
aidl_radio_stat->onTimeInMsForBgScan = legacy_radio_stat.stats.on_time_gscan;
aidl_radio_stat->onTimeInMsForRoamScan = legacy_radio_stat.stats.on_time_roam_scan;
aidl_radio_stat->onTimeInMsForPnoScan = legacy_radio_stat.stats.on_time_pno_scan;
aidl_radio_stat->onTimeInMsForHs20Scan = legacy_radio_stat.stats.on_time_hs20;
std::vector<WifiChannelStats> aidl_channel_stats;
for (const auto& channel_stat : legacy_radio_stat.channel_stats) {
WifiChannelStats aidl_channel_stat;
aidl_channel_stat.onTimeInMs = channel_stat.on_time;
aidl_channel_stat.ccaBusyTimeInMs = channel_stat.cca_busy_time;
aidl_channel_stat.channel.width = WifiChannelWidthInMhz::WIDTH_20;
aidl_channel_stat.channel.centerFreq = channel_stat.channel.center_freq;
aidl_channel_stat.channel.centerFreq0 = channel_stat.channel.center_freq0;
aidl_channel_stat.channel.centerFreq1 = channel_stat.channel.center_freq1;
aidl_channel_stats.push_back(aidl_channel_stat);
}
aidl_radio_stat->channelStats = aidl_channel_stats;
return true;
}
bool convertLegacyLinkLayerMlStatsToAidl(const legacy_hal::LinkLayerMlStats& legacy_ml_stats,
StaLinkLayerStats* aidl_stats) {
if (!aidl_stats) {
return false;
}
*aidl_stats = {};
std::vector<StaLinkLayerLinkStats> links;
// Iterate over each links
for (const auto& link : legacy_ml_stats.links) {
StaLinkLayerLinkStats linkStats = {};
linkStats.linkId = link.stat.link_id;
linkStats.radioId = link.stat.radio;
linkStats.frequencyMhz = link.stat.frequency;
linkStats.beaconRx = link.stat.beacon_rx;
linkStats.avgRssiMgmt = link.stat.rssi_mgmt;
linkStats.wmeBePktStats.rxMpdu = link.stat.ac[legacy_hal::WIFI_AC_BE].rx_mpdu;
linkStats.wmeBePktStats.txMpdu = link.stat.ac[legacy_hal::WIFI_AC_BE].tx_mpdu;
linkStats.wmeBePktStats.lostMpdu = link.stat.ac[legacy_hal::WIFI_AC_BE].mpdu_lost;
linkStats.wmeBePktStats.retries = link.stat.ac[legacy_hal::WIFI_AC_BE].retries;
linkStats.wmeBeContentionTimeStats.contentionTimeMinInUsec =
link.stat.ac[legacy_hal::WIFI_AC_BE].contention_time_min;
linkStats.wmeBeContentionTimeStats.contentionTimeMaxInUsec =
link.stat.ac[legacy_hal::WIFI_AC_BE].contention_time_max;
linkStats.wmeBeContentionTimeStats.contentionTimeAvgInUsec =
link.stat.ac[legacy_hal::WIFI_AC_BE].contention_time_avg;
linkStats.wmeBeContentionTimeStats.contentionNumSamples =
link.stat.ac[legacy_hal::WIFI_AC_BE].contention_num_samples;
linkStats.wmeBkPktStats.rxMpdu = link.stat.ac[legacy_hal::WIFI_AC_BK].rx_mpdu;
linkStats.wmeBkPktStats.txMpdu = link.stat.ac[legacy_hal::WIFI_AC_BK].tx_mpdu;
linkStats.wmeBkPktStats.lostMpdu = link.stat.ac[legacy_hal::WIFI_AC_BK].mpdu_lost;
linkStats.wmeBkPktStats.retries = link.stat.ac[legacy_hal::WIFI_AC_BK].retries;
linkStats.wmeBkContentionTimeStats.contentionTimeMinInUsec =
link.stat.ac[legacy_hal::WIFI_AC_BK].contention_time_min;
linkStats.wmeBkContentionTimeStats.contentionTimeMaxInUsec =
link.stat.ac[legacy_hal::WIFI_AC_BK].contention_time_max;
linkStats.wmeBkContentionTimeStats.contentionTimeAvgInUsec =
link.stat.ac[legacy_hal::WIFI_AC_BK].contention_time_avg;
linkStats.wmeBkContentionTimeStats.contentionNumSamples =
link.stat.ac[legacy_hal::WIFI_AC_BK].contention_num_samples;
linkStats.wmeViPktStats.rxMpdu = link.stat.ac[legacy_hal::WIFI_AC_VI].rx_mpdu;
linkStats.wmeViPktStats.txMpdu = link.stat.ac[legacy_hal::WIFI_AC_VI].tx_mpdu;
linkStats.wmeViPktStats.lostMpdu = link.stat.ac[legacy_hal::WIFI_AC_VI].mpdu_lost;
linkStats.wmeViPktStats.retries = link.stat.ac[legacy_hal::WIFI_AC_VI].retries;
linkStats.wmeViContentionTimeStats.contentionTimeMinInUsec =
link.stat.ac[legacy_hal::WIFI_AC_VI].contention_time_min;
linkStats.wmeViContentionTimeStats.contentionTimeMaxInUsec =
link.stat.ac[legacy_hal::WIFI_AC_VI].contention_time_max;
linkStats.wmeViContentionTimeStats.contentionTimeAvgInUsec =
link.stat.ac[legacy_hal::WIFI_AC_VI].contention_time_avg;
linkStats.wmeViContentionTimeStats.contentionNumSamples =
link.stat.ac[legacy_hal::WIFI_AC_VI].contention_num_samples;
linkStats.wmeVoPktStats.rxMpdu = link.stat.ac[legacy_hal::WIFI_AC_VO].rx_mpdu;
linkStats.wmeVoPktStats.txMpdu = link.stat.ac[legacy_hal::WIFI_AC_VO].tx_mpdu;
linkStats.wmeVoPktStats.lostMpdu = link.stat.ac[legacy_hal::WIFI_AC_VO].mpdu_lost;
linkStats.wmeVoPktStats.retries = link.stat.ac[legacy_hal::WIFI_AC_VO].retries;
linkStats.wmeVoContentionTimeStats.contentionTimeMinInUsec =
link.stat.ac[legacy_hal::WIFI_AC_VO].contention_time_min;
linkStats.wmeVoContentionTimeStats.contentionTimeMaxInUsec =
link.stat.ac[legacy_hal::WIFI_AC_VO].contention_time_max;
linkStats.wmeVoContentionTimeStats.contentionTimeAvgInUsec =
link.stat.ac[legacy_hal::WIFI_AC_VO].contention_time_avg;
linkStats.wmeVoContentionTimeStats.contentionNumSamples =
link.stat.ac[legacy_hal::WIFI_AC_VO].contention_num_samples;
linkStats.timeSliceDutyCycleInPercent = link.stat.time_slicing_duty_cycle_percent;
// peer info legacy_stats conversion.
std::vector<StaPeerInfo> aidl_peers_info_stats;
for (const auto& legacy_peer_info_stats : link.peers) {
StaPeerInfo aidl_peer_info_stats;
if (!convertLegacyPeerInfoStatsToAidl(legacy_peer_info_stats, &aidl_peer_info_stats)) {
return false;
}
aidl_peers_info_stats.push_back(aidl_peer_info_stats);
}
linkStats.peers = aidl_peers_info_stats;
// Push link stats to aidl stats.
links.push_back(linkStats);
}
aidl_stats->iface.links = links;
// radio legacy_stats conversion.
std::vector<StaLinkLayerRadioStats> aidl_radios_stats;
for (const auto& legacy_radio_stats : legacy_ml_stats.radios) {
StaLinkLayerRadioStats aidl_radio_stats;
if (!convertLegacyLinkLayerRadioStatsToAidl(legacy_radio_stats, &aidl_radio_stats)) {
return false;
}
aidl_radios_stats.push_back(aidl_radio_stats);
}
aidl_stats->radios = aidl_radios_stats;
aidl_stats->timeStampInMs = ::android::uptimeMillis();
return true;
}
bool convertLegacyLinkLayerStatsToAidl(const legacy_hal::LinkLayerStats& legacy_stats,
StaLinkLayerStats* aidl_stats) {
if (!aidl_stats) {
return false;
}
*aidl_stats = {};
std::vector<StaLinkLayerLinkStats> links;
StaLinkLayerLinkStats linkStats = {};
// iface legacy_stats conversion.
linkStats.linkId = 0;
linkStats.beaconRx = legacy_stats.iface.beacon_rx;
linkStats.avgRssiMgmt = legacy_stats.iface.rssi_mgmt;
linkStats.wmeBePktStats.rxMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu;
linkStats.wmeBePktStats.txMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu;
linkStats.wmeBePktStats.lostMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost;
linkStats.wmeBePktStats.retries = legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries;
linkStats.wmeBeContentionTimeStats.contentionTimeMinInUsec =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_min;
linkStats.wmeBeContentionTimeStats.contentionTimeMaxInUsec =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_max;
linkStats.wmeBeContentionTimeStats.contentionTimeAvgInUsec =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_avg;
linkStats.wmeBeContentionTimeStats.contentionNumSamples =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples;
linkStats.wmeBkPktStats.rxMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu;
linkStats.wmeBkPktStats.txMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu;
linkStats.wmeBkPktStats.lostMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost;
linkStats.wmeBkPktStats.retries = legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries;
linkStats.wmeBkContentionTimeStats.contentionTimeMinInUsec =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_min;
linkStats.wmeBkContentionTimeStats.contentionTimeMaxInUsec =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_max;
linkStats.wmeBkContentionTimeStats.contentionTimeAvgInUsec =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_avg;
linkStats.wmeBkContentionTimeStats.contentionNumSamples =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples;
linkStats.wmeViPktStats.rxMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu;
linkStats.wmeViPktStats.txMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu;
linkStats.wmeViPktStats.lostMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost;
linkStats.wmeViPktStats.retries = legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries;
linkStats.wmeViContentionTimeStats.contentionTimeMinInUsec =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_min;
linkStats.wmeViContentionTimeStats.contentionTimeMaxInUsec =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_max;
linkStats.wmeViContentionTimeStats.contentionTimeAvgInUsec =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_avg;
linkStats.wmeViContentionTimeStats.contentionNumSamples =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples;
linkStats.wmeVoPktStats.rxMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu;
linkStats.wmeVoPktStats.txMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu;
linkStats.wmeVoPktStats.lostMpdu = legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost;
linkStats.wmeVoPktStats.retries = legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries;
linkStats.wmeVoContentionTimeStats.contentionTimeMinInUsec =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_min;
linkStats.wmeVoContentionTimeStats.contentionTimeMaxInUsec =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_max;
linkStats.wmeVoContentionTimeStats.contentionTimeAvgInUsec =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_avg;
linkStats.wmeVoContentionTimeStats.contentionNumSamples =
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples;
linkStats.timeSliceDutyCycleInPercent = legacy_stats.iface.info.time_slicing_duty_cycle_percent;
// peer info legacy_stats conversion.
std::vector<StaPeerInfo> aidl_peers_info_stats;
for (const auto& legacy_peer_info_stats : legacy_stats.peers) {
StaPeerInfo aidl_peer_info_stats;
if (!convertLegacyPeerInfoStatsToAidl(legacy_peer_info_stats, &aidl_peer_info_stats)) {
return false;
}
aidl_peers_info_stats.push_back(aidl_peer_info_stats);
}
linkStats.peers = aidl_peers_info_stats;
links.push_back(linkStats);
aidl_stats->iface.links = links;
// radio legacy_stats conversion.
std::vector<StaLinkLayerRadioStats> aidl_radios_stats;
for (const auto& legacy_radio_stats : legacy_stats.radios) {
StaLinkLayerRadioStats aidl_radio_stats;
if (!convertLegacyLinkLayerRadioStatsToAidl(legacy_radio_stats, &aidl_radio_stats)) {
return false;
}
aidl_radios_stats.push_back(aidl_radio_stats);
}
aidl_stats->radios = aidl_radios_stats;
aidl_stats->timeStampInMs = ::android::uptimeMillis();
return true;
}
bool convertLegacyPeerInfoStatsToAidl(const legacy_hal::WifiPeerInfo& legacy_peer_info_stats,
StaPeerInfo* aidl_peer_info_stats) {
if (!aidl_peer_info_stats) {
return false;
}
*aidl_peer_info_stats = {};
aidl_peer_info_stats->staCount = legacy_peer_info_stats.peer_info.bssload.sta_count;
aidl_peer_info_stats->chanUtil = legacy_peer_info_stats.peer_info.bssload.chan_util;
std::vector<StaRateStat> aidlRateStats;
for (const auto& legacy_rate_stats : legacy_peer_info_stats.rate_stats) {
StaRateStat rateStat;
if (!convertLegacyWifiRateInfoToAidl(legacy_rate_stats.rate, &rateStat.rateInfo)) {
return false;
}
rateStat.txMpdu = legacy_rate_stats.tx_mpdu;
rateStat.rxMpdu = legacy_rate_stats.rx_mpdu;
rateStat.mpduLost = legacy_rate_stats.mpdu_lost;
rateStat.retries = legacy_rate_stats.retries;
aidlRateStats.push_back(rateStat);
}
aidl_peer_info_stats->rateStats = aidlRateStats;
return true;
}
bool convertLegacyRoamingCapabilitiesToAidl(
const legacy_hal::wifi_roaming_capabilities& legacy_caps,
StaRoamingCapabilities* aidl_caps) {
if (!aidl_caps) {
return false;
}
*aidl_caps = {};
aidl_caps->maxBlocklistSize = legacy_caps.max_blacklist_size;
aidl_caps->maxAllowlistSize = legacy_caps.max_whitelist_size;
return true;
}
bool convertAidlRoamingConfigToLegacy(const StaRoamingConfig& aidl_config,
legacy_hal::wifi_roaming_config* legacy_config) {
if (!legacy_config) {
return false;
}
*legacy_config = {};
if (aidl_config.bssidBlocklist.size() > MAX_BLACKLIST_BSSID ||
aidl_config.ssidAllowlist.size() > MAX_WHITELIST_SSID) {
return false;
}
legacy_config->num_blacklist_bssid = aidl_config.bssidBlocklist.size();
uint32_t i = 0;
for (const auto& bssid : aidl_config.bssidBlocklist) {
CHECK(bssid.data.size() == sizeof(legacy_hal::mac_addr));
memcpy(legacy_config->blacklist_bssid[i++], bssid.data.data(), bssid.data.size());
}
legacy_config->num_whitelist_ssid = aidl_config.ssidAllowlist.size();
i = 0;
for (const auto& ssid : aidl_config.ssidAllowlist) {
CHECK(ssid.data.size() <= sizeof(legacy_hal::ssid_t::ssid_str));
legacy_config->whitelist_ssid[i].length = ssid.data.size();
memcpy(legacy_config->whitelist_ssid[i].ssid_str, ssid.data.data(), ssid.data.size());
i++;
}
return true;
}
legacy_hal::fw_roaming_state_t convertAidlRoamingStateToLegacy(StaRoamingState state) {
switch (state) {
case StaRoamingState::ENABLED:
return legacy_hal::ROAMING_ENABLE;
case StaRoamingState::DISABLED:
return legacy_hal::ROAMING_DISABLE;
};
CHECK(false);
}
legacy_hal::NanMatchAlg convertAidlNanMatchAlgToLegacy(NanMatchAlg type) {
switch (type) {
case NanMatchAlg::MATCH_ONCE:
return legacy_hal::NAN_MATCH_ALG_MATCH_ONCE;
case NanMatchAlg::MATCH_CONTINUOUS:
return legacy_hal::NAN_MATCH_ALG_MATCH_CONTINUOUS;
case NanMatchAlg::MATCH_NEVER:
return legacy_hal::NAN_MATCH_ALG_MATCH_NEVER;
}
CHECK(false);
}
legacy_hal::NanPublishType convertAidlNanPublishTypeToLegacy(NanPublishType type) {
switch (type) {
case NanPublishType::UNSOLICITED:
return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED;
case NanPublishType::SOLICITED:
return legacy_hal::NAN_PUBLISH_TYPE_SOLICITED;
case NanPublishType::UNSOLICITED_SOLICITED:
return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
}
CHECK(false);
}
legacy_hal::NanTxType convertAidlNanTxTypeToLegacy(NanTxType type) {
switch (type) {
case NanTxType::BROADCAST:
return legacy_hal::NAN_TX_TYPE_BROADCAST;
case NanTxType::UNICAST:
return legacy_hal::NAN_TX_TYPE_UNICAST;
}
CHECK(false);
}
legacy_hal::NanSubscribeType convertAidlNanSubscribeTypeToLegacy(NanSubscribeType type) {
switch (type) {
case NanSubscribeType::PASSIVE:
return legacy_hal::NAN_SUBSCRIBE_TYPE_PASSIVE;
case NanSubscribeType::ACTIVE:
return legacy_hal::NAN_SUBSCRIBE_TYPE_ACTIVE;
}
CHECK(false);
}
legacy_hal::NanSRFType convertAidlNanSrfTypeToLegacy(NanSrfType type) {
switch (type) {
case NanSrfType::BLOOM_FILTER:
return legacy_hal::NAN_SRF_ATTR_BLOOM_FILTER;
case NanSrfType::PARTIAL_MAC_ADDR:
return legacy_hal::NAN_SRF_ATTR_PARTIAL_MAC_ADDR;
}
CHECK(false);
}
legacy_hal::NanDataPathChannelCfg convertAidlNanDataPathChannelCfgToLegacy(
NanDataPathChannelCfg type) {
switch (type) {
case NanDataPathChannelCfg::CHANNEL_NOT_REQUESTED:
return legacy_hal::NAN_DP_CHANNEL_NOT_REQUESTED;
case NanDataPathChannelCfg::REQUEST_CHANNEL_SETUP:
return legacy_hal::NAN_DP_REQUEST_CHANNEL_SETUP;
case NanDataPathChannelCfg::FORCE_CHANNEL_SETUP:
return legacy_hal::NAN_DP_FORCE_CHANNEL_SETUP;
}
CHECK(false);
}
legacy_hal::NanPairingRequestType convertAidlNanPairingRequestTypeToLegacy(
NanPairingRequestType type) {
switch (type) {
case NanPairingRequestType::NAN_PAIRING_SETUP:
return legacy_hal::NAN_PAIRING_SETUP;
case NanPairingRequestType::NAN_PAIRING_VERIFICATION:
return legacy_hal::NAN_PAIRING_VERIFICATION;
}
LOG(FATAL);
}
NanPairingRequestType convertLegacyNanPairingRequestTypeToAidl(
legacy_hal::NanPairingRequestType type) {
switch (type) {
case legacy_hal::NAN_PAIRING_SETUP:
return NanPairingRequestType::NAN_PAIRING_SETUP;
case legacy_hal::NAN_PAIRING_VERIFICATION:
return NanPairingRequestType::NAN_PAIRING_VERIFICATION;
}
LOG(FATAL);
}
legacy_hal::Akm convertAidlAkmTypeToLegacy(NanPairingAkm type) {
switch (type) {
case NanPairingAkm::SAE:
return legacy_hal::SAE;
case NanPairingAkm::PASN:
return legacy_hal::PASN;
}
LOG(FATAL);
}
NanPairingAkm convertLegacyAkmTypeToAidl(legacy_hal::Akm type) {
switch (type) {
case legacy_hal::SAE:
return NanPairingAkm::SAE;
case legacy_hal::PASN:
return NanPairingAkm::PASN;
}
LOG(FATAL);
}
uint16_t convertAidlBootstrappingMethodToLegacy(NanBootstrappingMethod type) {
switch (type) {
case NanBootstrappingMethod::BOOTSTRAPPING_OPPORTUNISTIC_MASK:
return NAN_PAIRING_BOOTSTRAPPING_OPPORTUNISTIC_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_PIN_CODE_DISPLAY_MASK:
return NAN_PAIRING_BOOTSTRAPPING_PIN_CODE_DISPLAY_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_PASSPHRASE_DISPLAY_MASK:
return NAN_PAIRING_BOOTSTRAPPING_PASSPHRASE_DISPLAY_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_QR_DISPLAY_MASK:
return NAN_PAIRING_BOOTSTRAPPING_QR_DISPLAY_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_NFC_TAG_MASK:
return NAN_PAIRING_BOOTSTRAPPING_NFC_TAG_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_PIN_CODE_KEYPAD_MASK:
return NAN_PAIRING_BOOTSTRAPPING_PIN_CODE_KEYPAD_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_PASSPHRASE_KEYPAD_MASK:
return NAN_PAIRING_BOOTSTRAPPING_PASSPHRASE_KEYPAD_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_QR_SCAN_MASK:
return NAN_PAIRING_BOOTSTRAPPING_QR_SCAN_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_NFC_READER_MASK:
return NAN_PAIRING_BOOTSTRAPPING_NFC_READER_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_SERVICE_MANAGED_MASK:
return NAN_PAIRING_BOOTSTRAPPING_SERVICE_MANAGED_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_HANDSHAKE_SHIP_MASK:
return NAN_PAIRING_BOOTSTRAPPING_HANDSHAKE_SHIP_MASK;
}
LOG(FATAL);
}
NanBootstrappingMethod convertLegacyBootstrappingMethodToAidl(uint16_t type) {
switch (type) {
case NAN_PAIRING_BOOTSTRAPPING_OPPORTUNISTIC_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_OPPORTUNISTIC_MASK;
case NAN_PAIRING_BOOTSTRAPPING_PIN_CODE_DISPLAY_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_PIN_CODE_DISPLAY_MASK;
case NAN_PAIRING_BOOTSTRAPPING_PASSPHRASE_DISPLAY_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_PASSPHRASE_DISPLAY_MASK;
case NAN_PAIRING_BOOTSTRAPPING_QR_DISPLAY_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_QR_DISPLAY_MASK;
case NAN_PAIRING_BOOTSTRAPPING_NFC_TAG_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_NFC_TAG_MASK;
case NAN_PAIRING_BOOTSTRAPPING_PIN_CODE_KEYPAD_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_PIN_CODE_KEYPAD_MASK;
case NAN_PAIRING_BOOTSTRAPPING_PASSPHRASE_KEYPAD_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_PASSPHRASE_KEYPAD_MASK;
case NAN_PAIRING_BOOTSTRAPPING_QR_SCAN_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_QR_SCAN_MASK;
case NAN_PAIRING_BOOTSTRAPPING_NFC_READER_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_NFC_READER_MASK;
case NAN_PAIRING_BOOTSTRAPPING_SERVICE_MANAGED_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_SERVICE_MANAGED_MASK;
case NAN_PAIRING_BOOTSTRAPPING_HANDSHAKE_SHIP_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_HANDSHAKE_SHIP_MASK;
}
LOG(FATAL);
return {};
}
bool covertAidlPairingConfigToLegacy(const NanPairingConfig& aidl_config,
legacy_hal::NanPairingConfig* legacy_config) {
if (!legacy_config) {
LOG(ERROR) << "covertAidlPairingConfigToLegacy: legacy_config is null";
return false;
}
legacy_config->enable_pairing_setup = aidl_config.enablePairingSetup ? 0x1 : 0x0;
legacy_config->enable_pairing_cache = aidl_config.enablePairingCache ? 0x1 : 0x0;
legacy_config->enable_pairing_verification = aidl_config.enablePairingVerification ? 0x1 : 0x0;
legacy_config->supported_bootstrapping_methods = aidl_config.supportedBootstrappingMethods;
return true;
}
bool convertLegacyPairingConfigToAidl(const legacy_hal::NanPairingConfig& legacy_config,
NanPairingConfig* aidl_config) {
if (!aidl_config) {
LOG(ERROR) << "convertLegacyPairingConfigToAidl: aidl_nira is null";
return false;
}
*aidl_config = {};
aidl_config->enablePairingSetup = legacy_config.enable_pairing_setup == 0x1;
aidl_config->enablePairingCache = legacy_config.enable_pairing_cache == 0x1;
aidl_config->enablePairingVerification = legacy_config.enable_pairing_verification == 0x1;
aidl_config->supportedBootstrappingMethods = legacy_config.supported_bootstrapping_methods;
return true;
}
bool convertLegacyNiraToAidl(const legacy_hal::NanIdentityResolutionAttribute& legacy_nira,
NanIdentityResolutionAttribute* aidl_nira) {
if (!aidl_nira) {
LOG(ERROR) << "convertLegacyNiraToAidl: aidl_nira is null";
return false;
}
*aidl_nira = {};
aidl_nira->nonce = std::array<uint8_t, 8>();
std::copy(legacy_nira.nonce, legacy_nira.nonce + 8, std::begin(aidl_nira->nonce));
aidl_nira->tag = std::array<uint8_t, 8>();
std::copy(legacy_nira.tag, legacy_nira.tag + 8, std::begin(aidl_nira->tag));
return true;
}
bool convertLegacyNpsaToAidl(const legacy_hal::NpkSecurityAssociation& legacy_npsa,
NpkSecurityAssociation* aidl_npsa) {
if (!aidl_npsa) {
LOG(ERROR) << "convertLegacyNiraToAidl: aidl_nira is null";
return false;
}
*aidl_npsa = {};
aidl_npsa->peerNanIdentityKey = std::array<uint8_t, 16>();
std::copy(legacy_npsa.peer_nan_identity_key, legacy_npsa.peer_nan_identity_key + 16,
std::begin(aidl_npsa->peerNanIdentityKey));
aidl_npsa->localNanIdentityKey = std::array<uint8_t, 16>();
std::copy(legacy_npsa.local_nan_identity_key, legacy_npsa.local_nan_identity_key + 16,
std::begin(aidl_npsa->localNanIdentityKey));
aidl_npsa->npk = std::array<uint8_t, 32>();
std::copy(legacy_npsa.npk.pmk, legacy_npsa.npk.pmk + 32, std::begin(aidl_npsa->npk));
aidl_npsa->akm = convertLegacyAkmTypeToAidl(legacy_npsa.akm);
return true;
}
NanStatusCode convertLegacyNanStatusTypeToAidl(legacy_hal::NanStatusType type) {
switch (type) {
case legacy_hal::NAN_STATUS_SUCCESS:
return NanStatusCode::SUCCESS;
case legacy_hal::NAN_STATUS_INTERNAL_FAILURE:
return NanStatusCode::INTERNAL_FAILURE;
case legacy_hal::NAN_STATUS_PROTOCOL_FAILURE:
return NanStatusCode::PROTOCOL_FAILURE;
case legacy_hal::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID:
return NanStatusCode::INVALID_SESSION_ID;
case legacy_hal::NAN_STATUS_NO_RESOURCE_AVAILABLE:
return NanStatusCode::NO_RESOURCES_AVAILABLE;
case legacy_hal::NAN_STATUS_INVALID_PARAM:
return NanStatusCode::INVALID_ARGS;
case legacy_hal::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID:
return NanStatusCode::INVALID_PEER_ID;
case legacy_hal::NAN_STATUS_INVALID_NDP_ID:
return NanStatusCode::INVALID_NDP_ID;
case legacy_hal::NAN_STATUS_NAN_NOT_ALLOWED:
return NanStatusCode::NAN_NOT_ALLOWED;
case legacy_hal::NAN_STATUS_NO_OTA_ACK:
return NanStatusCode::NO_OTA_ACK;
case legacy_hal::NAN_STATUS_ALREADY_ENABLED:
return NanStatusCode::ALREADY_ENABLED;
case legacy_hal::NAN_STATUS_FOLLOWUP_QUEUE_FULL:
return NanStatusCode::FOLLOWUP_TX_QUEUE_FULL;
case legacy_hal::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED:
return NanStatusCode::UNSUPPORTED_CONCURRENCY_NAN_DISABLED;
case legacy_hal::NAN_STATUS_INVALID_PAIRING_ID:
return NanStatusCode::INVALID_PAIRING_ID;
case legacy_hal::NAN_STATUS_INVALID_BOOTSTRAPPING_ID:
return NanStatusCode::INVALID_BOOTSTRAPPING_ID;
}
CHECK(false);
}
void convertToNanStatus(legacy_hal::NanStatusType type, const char* str, size_t max_len,
NanStatus* nanStatus) {
nanStatus->status = convertLegacyNanStatusTypeToAidl(type);
nanStatus->description = safeConvertChar(str, max_len);
}
bool convertAidlNanEnableRequestToLegacy(const NanEnableRequest& aidl_request1,
const NanConfigRequestSupplemental& aidl_request2,
legacy_hal::NanEnableRequest* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanEnableRequestToLegacy: null legacy_request";
return false;
}
*legacy_request = {};
legacy_request->config_2dot4g_support = 1;
legacy_request->support_2dot4g_val =
aidl_request1.operateInBand[(size_t)NanBandIndex::NAN_BAND_24GHZ];
legacy_request->config_support_5g = 1;
legacy_request->support_5g_val =
aidl_request1.operateInBand[(size_t)NanBandIndex::NAN_BAND_5GHZ];
legacy_request->config_hop_count_limit = 1;
legacy_request->hop_count_limit_val = aidl_request1.hopCountMax;
legacy_request->master_pref = aidl_request1.configParams.masterPref;
legacy_request->discovery_indication_cfg = 0;
legacy_request->discovery_indication_cfg |=
aidl_request1.configParams.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
legacy_request->discovery_indication_cfg |=
aidl_request1.configParams.disableStartedClusterIndication ? 0x2 : 0x0;
legacy_request->discovery_indication_cfg |=
aidl_request1.configParams.disableJoinedClusterIndication ? 0x4 : 0x0;
legacy_request->config_sid_beacon = 1;
if (aidl_request1.configParams.numberOfPublishServiceIdsInBeacon < 0) {
LOG(ERROR) << "convertAidlNanEnableRequestToLegacy: "
"numberOfPublishServiceIdsInBeacon < 0";
return false;
}
legacy_request->sid_beacon_val =
(aidl_request1.configParams.includePublishServiceIdsInBeacon ? 0x1 : 0x0) |
(aidl_request1.configParams.numberOfPublishServiceIdsInBeacon << 1);
legacy_request->config_subscribe_sid_beacon = 1;
if (aidl_request1.configParams.numberOfSubscribeServiceIdsInBeacon < 0) {
LOG(ERROR) << "convertAidlNanEnableRequestToLegacy: "
"numberOfSubscribeServiceIdsInBeacon < 0";
return false;
}
legacy_request->subscribe_sid_beacon_val =
(aidl_request1.configParams.includeSubscribeServiceIdsInBeacon ? 0x1 : 0x0) |
(aidl_request1.configParams.numberOfSubscribeServiceIdsInBeacon << 1);
legacy_request->config_rssi_window_size = 1;
legacy_request->rssi_window_size_val = aidl_request1.configParams.rssiWindowSize;
legacy_request->config_disc_mac_addr_randomization = 1;
legacy_request->disc_mac_addr_rand_interval_sec =
aidl_request1.configParams.macAddressRandomizationIntervalSec;
legacy_request->config_2dot4g_rssi_close = 1;
if (aidl_request1.configParams.bandSpecificConfig.size() != 3) {
LOG(ERROR) << "convertAidlNanEnableRequestToLegacy: "
"bandSpecificConfig.size() != 3";
return false;
}
legacy_request->rssi_close_2dot4g_val =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
.rssiClose;
legacy_request->config_2dot4g_rssi_middle = 1;
legacy_request->rssi_middle_2dot4g_val =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
.rssiMiddle;
legacy_request->config_2dot4g_rssi_proximity = 1;
legacy_request->rssi_proximity_2dot4g_val =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
.rssiCloseProximity;
legacy_request->config_scan_params = 1;
legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
.dwellTimeMs;
legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
.scanPeriodSec;
legacy_request->config_dw.config_2dot4g_dw_band =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
.validDiscoveryWindowIntervalVal;
legacy_request->config_dw.dw_2dot4g_interval_val =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
.discoveryWindowIntervalVal;
legacy_request->config_5g_rssi_close = 1;
legacy_request->rssi_close_5g_val =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
.rssiClose;
legacy_request->config_5g_rssi_middle = 1;
legacy_request->rssi_middle_5g_val =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
.rssiMiddle;
legacy_request->config_5g_rssi_close_proximity = 1;
legacy_request->rssi_close_proximity_5g_val =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
.rssiCloseProximity;
legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
.dwellTimeMs;
legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
.scanPeriodSec;
legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
.dwellTimeMs;
legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
.scanPeriodSec;
legacy_request->config_dw.config_5g_dw_band =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
.validDiscoveryWindowIntervalVal;
legacy_request->config_dw.dw_5g_interval_val =
aidl_request1.configParams.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
.discoveryWindowIntervalVal;
if (aidl_request1.debugConfigs.validClusterIdVals) {
legacy_request->cluster_low = aidl_request1.debugConfigs.clusterIdBottomRangeVal;
legacy_request->cluster_high = aidl_request1.debugConfigs.clusterIdTopRangeVal;
} else { // need 'else' since not configurable in legacy HAL
legacy_request->cluster_low = 0x0000;
legacy_request->cluster_high = 0xFFFF;
}
legacy_request->config_intf_addr = aidl_request1.debugConfigs.validIntfAddrVal;
memcpy(legacy_request->intf_addr_val, aidl_request1.debugConfigs.intfAddrVal.data(), 6);
legacy_request->config_oui = aidl_request1.debugConfigs.validOuiVal;
legacy_request->oui_val = aidl_request1.debugConfigs.ouiVal;
legacy_request->config_random_factor_force =
aidl_request1.debugConfigs.validRandomFactorForceVal;
legacy_request->random_factor_force_val = aidl_request1.debugConfigs.randomFactorForceVal;
legacy_request->config_hop_count_force = aidl_request1.debugConfigs.validHopCountForceVal;
legacy_request->hop_count_force_val = aidl_request1.debugConfigs.hopCountForceVal;
legacy_request->config_24g_channel = aidl_request1.debugConfigs.validDiscoveryChannelVal;
legacy_request->channel_24g_val =
aidl_request1.debugConfigs.discoveryChannelMhzVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
legacy_request->config_5g_channel = aidl_request1.debugConfigs.validDiscoveryChannelVal;
legacy_request->channel_5g_val =
aidl_request1.debugConfigs.discoveryChannelMhzVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
legacy_request->config_2dot4g_beacons = aidl_request1.debugConfigs.validUseBeaconsInBandVal;
legacy_request->beacon_2dot4g_val =
aidl_request1.debugConfigs.useBeaconsInBandVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
legacy_request->config_5g_beacons = aidl_request1.debugConfigs.validUseBeaconsInBandVal;
legacy_request->beacon_5g_val =
aidl_request1.debugConfigs.useBeaconsInBandVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
legacy_request->config_2dot4g_sdf = aidl_request1.debugConfigs.validUseSdfInBandVal;
legacy_request->sdf_2dot4g_val =
aidl_request1.debugConfigs.useSdfInBandVal[(size_t)NanBandIndex::NAN_BAND_24GHZ];
legacy_request->config_5g_sdf = aidl_request1.debugConfigs.validUseSdfInBandVal;
legacy_request->sdf_5g_val =
aidl_request1.debugConfigs.useSdfInBandVal[(size_t)NanBandIndex::NAN_BAND_5GHZ];
legacy_request->config_discovery_beacon_int = 1;
legacy_request->discovery_beacon_interval = aidl_request2.discoveryBeaconIntervalMs;
legacy_request->config_nss = 1;
legacy_request->nss = aidl_request2.numberOfSpatialStreamsInDiscovery;
legacy_request->config_dw_early_termination = 1;
legacy_request->enable_dw_termination = aidl_request2.enableDiscoveryWindowEarlyTermination;
legacy_request->config_enable_ranging = 1;
legacy_request->enable_ranging = aidl_request2.enableRanging;
legacy_request->config_enable_instant_mode = 1;
legacy_request->enable_instant_mode = aidl_request2.enableInstantCommunicationMode;
legacy_request->config_instant_mode_channel = 1;
legacy_request->instant_mode_channel = aidl_request2.instantModeChannel;
return true;
}
bool convertAidlNanConfigRequestToLegacy(const NanConfigRequest& aidl_request1,
const NanConfigRequestSupplemental& aidl_request2,
legacy_hal::NanConfigRequest* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanConfigRequestToLegacy: null legacy_request";
return false;
}
*legacy_request = {};
legacy_request->master_pref = aidl_request1.masterPref;
legacy_request->discovery_indication_cfg = 0;
legacy_request->discovery_indication_cfg |=
aidl_request1.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
legacy_request->discovery_indication_cfg |=
aidl_request1.disableStartedClusterIndication ? 0x2 : 0x0;
legacy_request->discovery_indication_cfg |=
aidl_request1.disableJoinedClusterIndication ? 0x4 : 0x0;
legacy_request->config_sid_beacon = 1;
if (aidl_request1.numberOfPublishServiceIdsInBeacon < 0) {
LOG(ERROR) << "convertAidlNanConfigRequestToLegacy: "
"numberOfPublishServiceIdsInBeacon < 0";
return false;
}
legacy_request->sid_beacon = (aidl_request1.includePublishServiceIdsInBeacon ? 0x1 : 0x0) |
(aidl_request1.numberOfPublishServiceIdsInBeacon << 1);
legacy_request->config_subscribe_sid_beacon = 1;
if (aidl_request1.numberOfSubscribeServiceIdsInBeacon < 0) {
LOG(ERROR) << "convertAidlNanConfigRequestToLegacy: "
"numberOfSubscribeServiceIdsInBeacon < 0";
return false;
}
legacy_request->subscribe_sid_beacon_val =
(aidl_request1.includeSubscribeServiceIdsInBeacon ? 0x1 : 0x0) |
(aidl_request1.numberOfSubscribeServiceIdsInBeacon << 1);
legacy_request->config_rssi_window_size = 1;
legacy_request->rssi_window_size_val = aidl_request1.rssiWindowSize;
legacy_request->config_disc_mac_addr_randomization = 1;
legacy_request->disc_mac_addr_rand_interval_sec =
aidl_request1.macAddressRandomizationIntervalSec;
legacy_request->config_scan_params = 1;
legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ].dwellTimeMs;
legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ].scanPeriodSec;
legacy_request->config_dw.config_2dot4g_dw_band =
aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
.validDiscoveryWindowIntervalVal;
legacy_request->config_dw.dw_2dot4g_interval_val =
aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_24GHZ]
.discoveryWindowIntervalVal;
legacy_request->config_5g_rssi_close_proximity = 1;
legacy_request->rssi_close_proximity_5g_val =
aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
.rssiCloseProximity;
legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
legacy_request->config_dw.config_5g_dw_band =
aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
.validDiscoveryWindowIntervalVal;
legacy_request->config_dw.dw_5g_interval_val =
aidl_request1.bandSpecificConfig[(size_t)NanBandIndex::NAN_BAND_5GHZ]
.discoveryWindowIntervalVal;
legacy_request->config_discovery_beacon_int = 1;
legacy_request->discovery_beacon_interval = aidl_request2.discoveryBeaconIntervalMs;
legacy_request->config_nss = 1;
legacy_request->nss = aidl_request2.numberOfSpatialStreamsInDiscovery;
legacy_request->config_dw_early_termination = 1;
legacy_request->enable_dw_termination = aidl_request2.enableDiscoveryWindowEarlyTermination;
legacy_request->config_enable_ranging = 1;
legacy_request->enable_ranging = aidl_request2.enableRanging;
legacy_request->config_enable_instant_mode = 1;
legacy_request->enable_instant_mode = aidl_request2.enableInstantCommunicationMode;
legacy_request->config_instant_mode_channel = 1;
legacy_request->instant_mode_channel = aidl_request2.instantModeChannel;
legacy_request->config_cluster_id = 1;
legacy_request->cluster_id_val = aidl_request2.clusterId;
return true;
}
bool convertAidlNanPublishRequestToLegacy(const NanPublishRequest& aidl_request,
legacy_hal::NanPublishRequest* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: null legacy_request";
return false;
}
*legacy_request = {};
legacy_request->publish_id = static_cast<uint8_t>(aidl_request.baseConfigs.sessionId);
legacy_request->ttl = aidl_request.baseConfigs.ttlSec;
legacy_request->period = aidl_request.baseConfigs.discoveryWindowPeriod;
legacy_request->publish_count = aidl_request.baseConfigs.discoveryCount;
legacy_request->service_name_len = aidl_request.baseConfigs.serviceName.size();
if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: service_name_len "
"too large";
return false;
}
memcpy(legacy_request->service_name, aidl_request.baseConfigs.serviceName.data(),
legacy_request->service_name_len);
legacy_request->publish_match_indicator =
convertAidlNanMatchAlgToLegacy(aidl_request.baseConfigs.discoveryMatchIndicator);
legacy_request->service_specific_info_len = aidl_request.baseConfigs.serviceSpecificInfo.size();
if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: "
"service_specific_info_len too large";
return false;
}
memcpy(legacy_request->service_specific_info,
aidl_request.baseConfigs.serviceSpecificInfo.data(),
legacy_request->service_specific_info_len);
legacy_request->sdea_service_specific_info_len =
aidl_request.baseConfigs.extendedServiceSpecificInfo.size();
if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: "
"sdea_service_specific_info_len too large";
return false;
}
memcpy(legacy_request->sdea_service_specific_info,
aidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
legacy_request->sdea_service_specific_info_len);
legacy_request->rx_match_filter_len = aidl_request.baseConfigs.rxMatchFilter.size();
if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: "
"rx_match_filter_len too large";
return false;
}
memcpy(legacy_request->rx_match_filter, aidl_request.baseConfigs.rxMatchFilter.data(),
legacy_request->rx_match_filter_len);
legacy_request->tx_match_filter_len = aidl_request.baseConfigs.txMatchFilter.size();
if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: "
"tx_match_filter_len too large";
return false;
}
memcpy(legacy_request->tx_match_filter, aidl_request.baseConfigs.txMatchFilter.data(),
legacy_request->tx_match_filter_len);
legacy_request->rssi_threshold_flag = aidl_request.baseConfigs.useRssiThreshold;
legacy_request->recv_indication_cfg = 0;
legacy_request->recv_indication_cfg |=
aidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1 : 0x0;
legacy_request->recv_indication_cfg |=
aidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
legacy_request->recv_indication_cfg |=
aidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
legacy_request->recv_indication_cfg |= 0x8;
legacy_request->cipher_type = (unsigned int)aidl_request.baseConfigs.securityConfig.cipherType;
legacy_request->scid_len = aidl_request.baseConfigs.securityConfig.scid.size();
if (legacy_request->scid_len > NAN_MAX_SCID_BUF_LEN) {
LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: scid_len too large";
return false;
}
memcpy(legacy_request->scid, aidl_request.baseConfigs.securityConfig.scid.data(),
legacy_request->scid_len);
if (aidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PMK) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
legacy_request->key_info.body.pmk_info.pmk_len =
aidl_request.baseConfigs.securityConfig.pmk.size();
if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: invalid pmk_len";
return false;
}
memcpy(legacy_request->key_info.body.pmk_info.pmk,
aidl_request.baseConfigs.securityConfig.pmk.data(),
legacy_request->key_info.body.pmk_info.pmk_len);
}
if (aidl_request.baseConfigs.securityConfig.securityType ==
NanDataPathSecurityType::PASSPHRASE) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
legacy_request->key_info.body.passphrase_info.passphrase_len =
aidl_request.baseConfigs.securityConfig.passphrase.size();
if (legacy_request->key_info.body.passphrase_info.passphrase_len <
NAN_SECURITY_MIN_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: "
"passphrase_len too small";
return false;
}
if (legacy_request->key_info.body.passphrase_info.passphrase_len >
NAN_SECURITY_MAX_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: "
"passphrase_len too large";
return false;
}
memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
aidl_request.baseConfigs.securityConfig.passphrase.data(),
legacy_request->key_info.body.passphrase_info.passphrase_len);
}
legacy_request->sdea_params.security_cfg =
(aidl_request.baseConfigs.securityConfig.securityType != NanDataPathSecurityType::OPEN)
? legacy_hal::NAN_DP_CONFIG_SECURITY
: legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
legacy_request->sdea_params.ranging_state = aidl_request.baseConfigs.rangingRequired
? legacy_hal::NAN_RANGING_ENABLE
: legacy_hal::NAN_RANGING_DISABLE;
legacy_request->ranging_cfg.ranging_interval_msec = aidl_request.baseConfigs.rangingIntervalMs;
legacy_request->ranging_cfg.config_ranging_indications =
static_cast<uint32_t>(aidl_request.baseConfigs.configRangingIndications);
legacy_request->ranging_cfg.distance_ingress_mm =
aidl_request.baseConfigs.distanceIngressCm * 10;
legacy_request->ranging_cfg.distance_egress_mm = aidl_request.baseConfigs.distanceEgressCm * 10;
legacy_request->ranging_auto_response = aidl_request.baseConfigs.rangingRequired
? legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE
: legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT;
legacy_request->publish_type = convertAidlNanPublishTypeToLegacy(aidl_request.publishType);
legacy_request->tx_type = convertAidlNanTxTypeToLegacy(aidl_request.txType);
legacy_request->service_responder_policy = aidl_request.autoAcceptDataPathRequests
? legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL
: legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE;
memcpy(legacy_request->nan_identity_key, aidl_request.identityKey.data(), NAN_IDENTITY_KEY_LEN);
if (!covertAidlPairingConfigToLegacy(aidl_request.pairingConfig,
&legacy_request->nan_pairing_config)) {
LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: invalid pairing config";
return false;
}
legacy_request->enable_suspendability = aidl_request.baseConfigs.enableSessionSuspendability;
return true;
}
bool convertAidlNanSubscribeRequestToLegacy(const NanSubscribeRequest& aidl_request,
legacy_hal::NanSubscribeRequest* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: legacy_request is null";
return false;
}
*legacy_request = {};
legacy_request->subscribe_id = static_cast<uint8_t>(aidl_request.baseConfigs.sessionId);
legacy_request->ttl = aidl_request.baseConfigs.ttlSec;
legacy_request->period = aidl_request.baseConfigs.discoveryWindowPeriod;
legacy_request->subscribe_count = aidl_request.baseConfigs.discoveryCount;
legacy_request->service_name_len = aidl_request.baseConfigs.serviceName.size();
if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
"service_name_len too large";
return false;
}
memcpy(legacy_request->service_name, aidl_request.baseConfigs.serviceName.data(),
legacy_request->service_name_len);
legacy_request->subscribe_match_indicator =
convertAidlNanMatchAlgToLegacy(aidl_request.baseConfigs.discoveryMatchIndicator);
legacy_request->service_specific_info_len = aidl_request.baseConfigs.serviceSpecificInfo.size();
if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
"service_specific_info_len too large";
return false;
}
memcpy(legacy_request->service_specific_info,
aidl_request.baseConfigs.serviceSpecificInfo.data(),
legacy_request->service_specific_info_len);
legacy_request->sdea_service_specific_info_len =
aidl_request.baseConfigs.extendedServiceSpecificInfo.size();
if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
"sdea_service_specific_info_len too large";
return false;
}
memcpy(legacy_request->sdea_service_specific_info,
aidl_request.baseConfigs.extendedServiceSpecificInfo.data(),
legacy_request->sdea_service_specific_info_len);
legacy_request->rx_match_filter_len = aidl_request.baseConfigs.rxMatchFilter.size();
if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
"rx_match_filter_len too large";
return false;
}
memcpy(legacy_request->rx_match_filter, aidl_request.baseConfigs.rxMatchFilter.data(),
legacy_request->rx_match_filter_len);
legacy_request->tx_match_filter_len = aidl_request.baseConfigs.txMatchFilter.size();
if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
"tx_match_filter_len too large";
return false;
}
memcpy(legacy_request->tx_match_filter, aidl_request.baseConfigs.txMatchFilter.data(),
legacy_request->tx_match_filter_len);
legacy_request->rssi_threshold_flag = aidl_request.baseConfigs.useRssiThreshold;
legacy_request->recv_indication_cfg = 0;
legacy_request->recv_indication_cfg |=
aidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1 : 0x0;
legacy_request->recv_indication_cfg |=
aidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
legacy_request->recv_indication_cfg |=
aidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
legacy_request->cipher_type = (unsigned int)aidl_request.baseConfigs.securityConfig.cipherType;
if (aidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PMK) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
legacy_request->key_info.body.pmk_info.pmk_len =
aidl_request.baseConfigs.securityConfig.pmk.size();
if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: invalid pmk_len";
return false;
}
memcpy(legacy_request->key_info.body.pmk_info.pmk,
aidl_request.baseConfigs.securityConfig.pmk.data(),
legacy_request->key_info.body.pmk_info.pmk_len);
}
if (aidl_request.baseConfigs.securityConfig.securityType ==
NanDataPathSecurityType::PASSPHRASE) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
legacy_request->key_info.body.passphrase_info.passphrase_len =
aidl_request.baseConfigs.securityConfig.passphrase.size();
if (legacy_request->key_info.body.passphrase_info.passphrase_len <
NAN_SECURITY_MIN_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
"passphrase_len too small";
return false;
}
if (legacy_request->key_info.body.passphrase_info.passphrase_len >
NAN_SECURITY_MAX_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
"passphrase_len too large";
return false;
}
memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
aidl_request.baseConfigs.securityConfig.passphrase.data(),
legacy_request->key_info.body.passphrase_info.passphrase_len);
}
legacy_request->sdea_params.security_cfg =
(aidl_request.baseConfigs.securityConfig.securityType != NanDataPathSecurityType::OPEN)
? legacy_hal::NAN_DP_CONFIG_SECURITY
: legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
legacy_request->sdea_params.ranging_state = aidl_request.baseConfigs.rangingRequired
? legacy_hal::NAN_RANGING_ENABLE
: legacy_hal::NAN_RANGING_DISABLE;
legacy_request->ranging_cfg.ranging_interval_msec = aidl_request.baseConfigs.rangingIntervalMs;
legacy_request->ranging_cfg.config_ranging_indications =
static_cast<uint32_t>(aidl_request.baseConfigs.configRangingIndications);
legacy_request->ranging_cfg.distance_ingress_mm =
aidl_request.baseConfigs.distanceIngressCm * 10;
legacy_request->ranging_cfg.distance_egress_mm = aidl_request.baseConfigs.distanceEgressCm * 10;
legacy_request->ranging_auto_response = aidl_request.baseConfigs.rangingRequired
? legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE
: legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT;
legacy_request->subscribe_type =
convertAidlNanSubscribeTypeToLegacy(aidl_request.subscribeType);
legacy_request->serviceResponseFilter = convertAidlNanSrfTypeToLegacy(aidl_request.srfType);
legacy_request->serviceResponseInclude = aidl_request.srfRespondIfInAddressSet
? legacy_hal::NAN_SRF_INCLUDE_RESPOND
: legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
legacy_request->useServiceResponseFilter =
aidl_request.shouldUseSrf ? legacy_hal::NAN_USE_SRF : legacy_hal::NAN_DO_NOT_USE_SRF;
legacy_request->ssiRequiredForMatchIndication =
aidl_request.isSsiRequiredForMatch ? legacy_hal::NAN_SSI_REQUIRED_IN_MATCH_IND
: legacy_hal::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND;
legacy_request->num_intf_addr_present = aidl_request.intfAddr.size();
if (legacy_request->num_intf_addr_present > NAN_MAX_SUBSCRIBE_MAX_ADDRESS) {
LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: "
"num_intf_addr_present - too many";
return false;
}
for (int i = 0; i < legacy_request->num_intf_addr_present; i++) {
memcpy(legacy_request->intf_addr[i], aidl_request.intfAddr[i].data.data(), 6);
}
memcpy(legacy_request->nan_identity_key, aidl_request.identityKey.data(), NAN_IDENTITY_KEY_LEN);
if (!covertAidlPairingConfigToLegacy(aidl_request.pairingConfig,
&legacy_request->nan_pairing_config)) {
LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: invalid pairing config";
return false;
}
legacy_request->enable_suspendability = aidl_request.baseConfigs.enableSessionSuspendability;
return true;
}
bool convertAidlNanTransmitFollowupRequestToLegacy(
const NanTransmitFollowupRequest& aidl_request,
legacy_hal::NanTransmitFollowupRequest* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanTransmitFollowupRequestToLegacy: "
"legacy_request is null";
return false;
}
*legacy_request = {};
legacy_request->publish_subscribe_id = static_cast<uint8_t>(aidl_request.discoverySessionId);
legacy_request->requestor_instance_id = aidl_request.peerId;
memcpy(legacy_request->addr, aidl_request.addr.data(), 6);
legacy_request->priority = aidl_request.isHighPriority ? legacy_hal::NAN_TX_PRIORITY_HIGH
: legacy_hal::NAN_TX_PRIORITY_NORMAL;
legacy_request->dw_or_faw = aidl_request.shouldUseDiscoveryWindow
? legacy_hal::NAN_TRANSMIT_IN_DW
: legacy_hal::NAN_TRANSMIT_IN_FAW;
legacy_request->service_specific_info_len = aidl_request.serviceSpecificInfo.size();
if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
LOG(ERROR) << "convertAidlNanTransmitFollowupRequestToLegacy: "
"service_specific_info_len too large";
return false;
}
memcpy(legacy_request->service_specific_info, aidl_request.serviceSpecificInfo.data(),
legacy_request->service_specific_info_len);
legacy_request->sdea_service_specific_info_len =
aidl_request.extendedServiceSpecificInfo.size();
if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
LOG(ERROR) << "convertAidlNanTransmitFollowupRequestToLegacy: "
"sdea_service_specific_info_len too large";
return false;
}
memcpy(legacy_request->sdea_service_specific_info,
aidl_request.extendedServiceSpecificInfo.data(),
legacy_request->sdea_service_specific_info_len);
legacy_request->recv_indication_cfg = aidl_request.disableFollowupResultIndication ? 0x1 : 0x0;
return true;
}
bool convertAidlNanDataPathInitiatorRequestToLegacy(
const NanInitiateDataPathRequest& aidl_request,
legacy_hal::NanDataPathInitiatorRequest* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: "
"legacy_request is null";
return false;
}
*legacy_request = {};
legacy_request->requestor_instance_id = aidl_request.peerId;
memcpy(legacy_request->peer_disc_mac_addr, aidl_request.peerDiscMacAddr.data(), 6);
legacy_request->channel_request_type =
convertAidlNanDataPathChannelCfgToLegacy(aidl_request.channelRequestType);
legacy_request->channel = aidl_request.channel;
if (strnlen(aidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: "
"ifaceName too long";
return false;
}
strlcpy(legacy_request->ndp_iface, aidl_request.ifaceName.c_str(), IFNAMSIZ + 1);
legacy_request->ndp_cfg.security_cfg =
(aidl_request.securityConfig.securityType != NanDataPathSecurityType::OPEN)
? legacy_hal::NAN_DP_CONFIG_SECURITY
: legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
legacy_request->app_info.ndp_app_info_len = aidl_request.appInfo.size();
if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: "
"ndp_app_info_len too large";
return false;
}
memcpy(legacy_request->app_info.ndp_app_info, aidl_request.appInfo.data(),
legacy_request->app_info.ndp_app_info_len);
legacy_request->cipher_type = (unsigned int)aidl_request.securityConfig.cipherType;
if (aidl_request.securityConfig.securityType == NanDataPathSecurityType::PMK) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
legacy_request->key_info.body.pmk_info.pmk_len = aidl_request.securityConfig.pmk.size();
if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: "
"invalid pmk_len";
return false;
}
memcpy(legacy_request->key_info.body.pmk_info.pmk, aidl_request.securityConfig.pmk.data(),
legacy_request->key_info.body.pmk_info.pmk_len);
}
if (aidl_request.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
legacy_request->key_info.body.passphrase_info.passphrase_len =
aidl_request.securityConfig.passphrase.size();
if (legacy_request->key_info.body.passphrase_info.passphrase_len <
NAN_SECURITY_MIN_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: "
"passphrase_len too small";
return false;
}
if (legacy_request->key_info.body.passphrase_info.passphrase_len >
NAN_SECURITY_MAX_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: "
"passphrase_len too large";
return false;
}
memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
aidl_request.securityConfig.passphrase.data(),
legacy_request->key_info.body.passphrase_info.passphrase_len);
}
legacy_request->service_name_len = aidl_request.serviceNameOutOfBand.size();
if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: "
"service_name_len too large";
return false;
}
memcpy(legacy_request->service_name, aidl_request.serviceNameOutOfBand.data(),
legacy_request->service_name_len);
legacy_request->scid_len = aidl_request.securityConfig.scid.size();
if (legacy_request->scid_len > NAN_MAX_SCID_BUF_LEN) {
LOG(ERROR) << "convertAidlNanDataPathInitiatorRequestToLegacy: scid_len too large";
return false;
}
memcpy(legacy_request->scid, aidl_request.securityConfig.scid.data(), legacy_request->scid_len);
return true;
}
bool convertAidlNanDataPathIndicationResponseToLegacy(
const NanRespondToDataPathIndicationRequest& aidl_request,
legacy_hal::NanDataPathIndicationResponse* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: "
"legacy_request is null";
return false;
}
*legacy_request = {};
legacy_request->rsp_code = aidl_request.acceptRequest ? legacy_hal::NAN_DP_REQUEST_ACCEPT
: legacy_hal::NAN_DP_REQUEST_REJECT;
legacy_request->ndp_instance_id = aidl_request.ndpInstanceId;
if (strnlen(aidl_request.ifaceName.c_str(), IFNAMSIZ + 1) == IFNAMSIZ + 1) {
LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: "
"ifaceName too long";
return false;
}
strlcpy(legacy_request->ndp_iface, aidl_request.ifaceName.c_str(), IFNAMSIZ + 1);
legacy_request->ndp_cfg.security_cfg =
(aidl_request.securityConfig.securityType != NanDataPathSecurityType::OPEN)
? legacy_hal::NAN_DP_CONFIG_SECURITY
: legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
legacy_request->app_info.ndp_app_info_len = aidl_request.appInfo.size();
if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: "
"ndp_app_info_len too large";
return false;
}
memcpy(legacy_request->app_info.ndp_app_info, aidl_request.appInfo.data(),
legacy_request->app_info.ndp_app_info_len);
legacy_request->cipher_type = (unsigned int)aidl_request.securityConfig.cipherType;
if (aidl_request.securityConfig.securityType == NanDataPathSecurityType::PMK) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
legacy_request->key_info.body.pmk_info.pmk_len = aidl_request.securityConfig.pmk.size();
if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: "
"invalid pmk_len";
return false;
}
memcpy(legacy_request->key_info.body.pmk_info.pmk, aidl_request.securityConfig.pmk.data(),
legacy_request->key_info.body.pmk_info.pmk_len);
}
if (aidl_request.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
legacy_request->key_info.body.passphrase_info.passphrase_len =
aidl_request.securityConfig.passphrase.size();
if (legacy_request->key_info.body.passphrase_info.passphrase_len <
NAN_SECURITY_MIN_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: "
"passphrase_len too small";
return false;
}
if (legacy_request->key_info.body.passphrase_info.passphrase_len >
NAN_SECURITY_MAX_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: "
"passphrase_len too large";
return false;
}
memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
aidl_request.securityConfig.passphrase.data(),
legacy_request->key_info.body.passphrase_info.passphrase_len);
}
legacy_request->service_name_len = aidl_request.serviceNameOutOfBand.size();
if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: "
"service_name_len too large";
return false;
}
memcpy(legacy_request->service_name, aidl_request.serviceNameOutOfBand.data(),
legacy_request->service_name_len);
legacy_request->scid_len = aidl_request.securityConfig.scid.size();
if (legacy_request->scid_len > NAN_MAX_SCID_BUF_LEN) {
LOG(ERROR) << "convertAidlNanDataPathIndicationResponseToLegacy: scid_len too large";
return false;
}
memcpy(legacy_request->scid, aidl_request.securityConfig.scid.data(), legacy_request->scid_len);
return true;
}
bool convertLegacyNanResponseHeaderToAidl(const legacy_hal::NanResponseMsg& legacy_response,
NanStatus* nanStatus) {
if (!nanStatus) {
LOG(ERROR) << "convertLegacyNanResponseHeaderToAidl: nanStatus is null";
return false;
}
*nanStatus = {};
convertToNanStatus(legacy_response.status, legacy_response.nan_error,
sizeof(legacy_response.nan_error), nanStatus);
return true;
}
bool convertLegacyNanCapabilitiesResponseToAidl(const legacy_hal::NanCapabilities& legacy_response,
NanCapabilities* aidl_response) {
if (!aidl_response) {
LOG(ERROR) << "convertLegacyNanCapabilitiesResponseToAidl: "
"aidl_response is null";
return false;
}
*aidl_response = {};
aidl_response->maxConcurrentClusters = legacy_response.max_concurrent_nan_clusters;
aidl_response->maxPublishes = legacy_response.max_publishes;
aidl_response->maxSubscribes = legacy_response.max_subscribes;
aidl_response->maxServiceNameLen = legacy_response.max_service_name_len;
aidl_response->maxMatchFilterLen = legacy_response.max_match_filter_len;
aidl_response->maxTotalMatchFilterLen = legacy_response.max_total_match_filter_len;
aidl_response->maxServiceSpecificInfoLen = legacy_response.max_service_specific_info_len;
aidl_response->maxExtendedServiceSpecificInfoLen =
legacy_response.max_sdea_service_specific_info_len;
aidl_response->maxNdiInterfaces = legacy_response.max_ndi_interfaces;
aidl_response->maxNdpSessions = legacy_response.max_ndp_sessions;
aidl_response->maxAppInfoLen = legacy_response.max_app_info_len;
aidl_response->maxQueuedTransmitFollowupMsgs =
legacy_response.max_queued_transmit_followup_msgs;
aidl_response->maxSubscribeInterfaceAddresses = legacy_response.max_subscribe_address;
aidl_response->supportedCipherSuites =
static_cast<NanCipherSuiteType>(legacy_response.cipher_suites_supported);
aidl_response->instantCommunicationModeSupportFlag = legacy_response.is_instant_mode_supported;
aidl_response->supports6g = legacy_response.is_6g_supported;
aidl_response->supportsHe = legacy_response.is_he_supported;
aidl_response->supportsPairing = legacy_response.is_pairing_supported;
aidl_response->supportsSetClusterId = legacy_response.is_set_cluster_id_supported;
aidl_response->supportsSuspension = legacy_response.is_suspension_supported;
return true;
}
bool convertLegacyNanMatchIndToAidl(const legacy_hal::NanMatchInd& legacy_ind,
NanMatchInd* aidl_ind) {
if (!aidl_ind) {
LOG(ERROR) << "convertLegacyNanMatchIndToAidl: aidl_ind is null";
return false;
}
*aidl_ind = {};
aidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
aidl_ind->peerId = legacy_ind.requestor_instance_id;
aidl_ind->addr = std::array<uint8_t, 6>();
std::copy(legacy_ind.addr, legacy_ind.addr + 6, std::begin(aidl_ind->addr));
aidl_ind->serviceSpecificInfo = std::vector<uint8_t>(
legacy_ind.service_specific_info,
legacy_ind.service_specific_info + legacy_ind.service_specific_info_len);
aidl_ind->extendedServiceSpecificInfo = std::vector<uint8_t>(
legacy_ind.sdea_service_specific_info,
legacy_ind.sdea_service_specific_info + legacy_ind.sdea_service_specific_info_len);
aidl_ind->matchFilter =
std::vector<uint8_t>(legacy_ind.sdf_match_filter,
legacy_ind.sdf_match_filter + legacy_ind.sdf_match_filter_len);
aidl_ind->matchOccurredInBeaconFlag = legacy_ind.match_occured_flag == 1; // NOTYPO
aidl_ind->outOfResourceFlag = legacy_ind.out_of_resource_flag == 1;
aidl_ind->rssiValue = legacy_ind.rssi_value;
aidl_ind->peerCipherType = (NanCipherSuiteType)legacy_ind.peer_cipher_type;
aidl_ind->peerRequiresSecurityEnabledInNdp =
legacy_ind.peer_sdea_params.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
aidl_ind->peerRequiresRanging =
legacy_ind.peer_sdea_params.ranging_state == legacy_hal::NAN_RANGING_ENABLE;
aidl_ind->rangingMeasurementInMm = legacy_ind.range_info.range_measurement_mm;
aidl_ind->rangingIndicationType =
static_cast<NanRangingIndication>(legacy_ind.range_info.ranging_event_type);
aidl_ind->scid = std::vector<uint8_t>(legacy_ind.scid, legacy_ind.scid + legacy_ind.scid_len);
if (!convertLegacyNiraToAidl(legacy_ind.nira, &aidl_ind->peerNira)) {
LOG(ERROR) << "convertLegacyNanMatchIndToAidl: invalid NIRA";
return false;
}
if (!convertLegacyPairingConfigToAidl(legacy_ind.peer_pairing_config,
&aidl_ind->peerPairingConfig)) {
LOG(ERROR) << "convertLegacyNanMatchIndToAidl: invalid pairing config";
return false;
}
return true;
}
bool convertLegacyNanFollowupIndToAidl(const legacy_hal::NanFollowupInd& legacy_ind,
NanFollowupReceivedInd* aidl_ind) {
if (!aidl_ind) {
LOG(ERROR) << "convertLegacyNanFollowupIndToAidl: aidl_ind is null";
return false;
}
*aidl_ind = {};
aidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
aidl_ind->peerId = legacy_ind.requestor_instance_id;
aidl_ind->addr = std::array<uint8_t, 6>();
std::copy(legacy_ind.addr, legacy_ind.addr + 6, std::begin(aidl_ind->addr));
aidl_ind->receivedInFaw = legacy_ind.dw_or_faw == 1;
aidl_ind->serviceSpecificInfo = std::vector<uint8_t>(
legacy_ind.service_specific_info,
legacy_ind.service_specific_info + legacy_ind.service_specific_info_len);
aidl_ind->extendedServiceSpecificInfo = std::vector<uint8_t>(
legacy_ind.sdea_service_specific_info,
legacy_ind.sdea_service_specific_info + legacy_ind.sdea_service_specific_info_len);
return true;
}
bool convertLegacyNanDataPathRequestIndToAidl(const legacy_hal::NanDataPathRequestInd& legacy_ind,
NanDataPathRequestInd* aidl_ind) {
if (!aidl_ind) {
LOG(ERROR) << "convertLegacyNanDataPathRequestIndToAidl: aidl_ind is null";
return false;
}
*aidl_ind = {};
aidl_ind->discoverySessionId = legacy_ind.service_instance_id;
aidl_ind->peerDiscMacAddr = std::array<uint8_t, 6>();
std::copy(legacy_ind.peer_disc_mac_addr, legacy_ind.peer_disc_mac_addr + 6,
std::begin(aidl_ind->peerDiscMacAddr));
aidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
aidl_ind->securityRequired =
legacy_ind.ndp_cfg.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
aidl_ind->appInfo = std::vector<uint8_t>(
legacy_ind.app_info.ndp_app_info,
legacy_ind.app_info.ndp_app_info + legacy_ind.app_info.ndp_app_info_len);
return true;
}
bool convertLegacyNdpChannelInfoToAidl(const legacy_hal::NanChannelInfo& legacy_struct,
NanDataPathChannelInfo* aidl_struct) {
if (!aidl_struct) {
LOG(ERROR) << "convertLegacyNdpChannelInfoToAidl: aidl_struct is null";
return false;
}
*aidl_struct = {};
aidl_struct->channelFreq = legacy_struct.channel;
aidl_struct->channelBandwidth = convertLegacyWifiChannelWidthToAidl(
(legacy_hal::wifi_channel_width)legacy_struct.bandwidth);
aidl_struct->numSpatialStreams = legacy_struct.nss;
return true;
}
bool convertLegacyNanDataPathConfirmIndToAidl(const legacy_hal::NanDataPathConfirmInd& legacy_ind,
NanDataPathConfirmInd* aidl_ind) {
if (!aidl_ind) {
LOG(ERROR) << "convertLegacyNanDataPathConfirmIndToAidl: aidl_ind is null";
return false;
}
*aidl_ind = {};
aidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
aidl_ind->dataPathSetupSuccess = legacy_ind.rsp_code == legacy_hal::NAN_DP_REQUEST_ACCEPT;
aidl_ind->peerNdiMacAddr = std::array<uint8_t, 6>();
std::copy(legacy_ind.peer_ndi_mac_addr, legacy_ind.peer_ndi_mac_addr + 6,
std::begin(aidl_ind->peerNdiMacAddr));
aidl_ind->appInfo = std::vector<uint8_t>(
legacy_ind.app_info.ndp_app_info,
legacy_ind.app_info.ndp_app_info + legacy_ind.app_info.ndp_app_info_len);
aidl_ind->status.status = convertLegacyNanStatusTypeToAidl(legacy_ind.reason_code);
aidl_ind->status.description = "";
std::vector<NanDataPathChannelInfo> channelInfo;
for (unsigned int i = 0; i < legacy_ind.num_channels; ++i) {
NanDataPathChannelInfo aidl_struct;
if (!convertLegacyNdpChannelInfoToAidl(legacy_ind.channel_info[i], &aidl_struct)) {
return false;
}
channelInfo.push_back(aidl_struct);
}
aidl_ind->channelInfo = channelInfo;
return true;
}
bool convertLegacyNanDataPathScheduleUpdateIndToAidl(
const legacy_hal::NanDataPathScheduleUpdateInd& legacy_ind,
NanDataPathScheduleUpdateInd* aidl_ind) {
if (!aidl_ind) {
LOG(ERROR) << "convertLegacyNanDataPathScheduleUpdateIndToAidl: "
"aidl_ind is null";
return false;
}
*aidl_ind = {};
aidl_ind->peerDiscoveryAddress = std::array<uint8_t, 6>();
std::copy(legacy_ind.peer_mac_addr, legacy_ind.peer_mac_addr + 6,
std::begin(aidl_ind->peerDiscoveryAddress));
std::vector<NanDataPathChannelInfo> channelInfo;
for (unsigned int i = 0; i < legacy_ind.num_channels; ++i) {
NanDataPathChannelInfo aidl_struct;
if (!convertLegacyNdpChannelInfoToAidl(legacy_ind.channel_info[i], &aidl_struct)) {
return false;
}
channelInfo.push_back(aidl_struct);
}
aidl_ind->channelInfo = channelInfo;
std::vector<uint32_t> ndpInstanceIds;
for (unsigned int i = 0; i < legacy_ind.num_ndp_instances; ++i) {
ndpInstanceIds.push_back(legacy_ind.ndp_instance_id[i]);
}
aidl_ind->ndpInstanceIds = uintToIntVec(ndpInstanceIds);
return true;
}
legacy_hal::wifi_rtt_type convertAidlRttTypeToLegacy(RttType type) {
switch (type) {
case RttType::ONE_SIDED:
return legacy_hal::RTT_TYPE_1_SIDED;
case RttType::TWO_SIDED:
return legacy_hal::RTT_TYPE_2_SIDED;
};
CHECK(false);
}
RttType convertLegacyRttTypeToAidl(legacy_hal::wifi_rtt_type type) {
switch (type) {
case legacy_hal::RTT_TYPE_1_SIDED:
return RttType::ONE_SIDED;
case legacy_hal::RTT_TYPE_2_SIDED:
return RttType::TWO_SIDED;
};
CHECK(false) << "Unknown legacy type: " << type;
}
legacy_hal::rtt_peer_type convertAidlRttPeerTypeToLegacy(RttPeerType type) {
switch (type) {
case RttPeerType::AP:
return legacy_hal::RTT_PEER_AP;
case RttPeerType::STA:
return legacy_hal::RTT_PEER_STA;
case RttPeerType::P2P_GO:
return legacy_hal::RTT_PEER_P2P_GO;
case RttPeerType::P2P_CLIENT:
return legacy_hal::RTT_PEER_P2P_CLIENT;
case RttPeerType::NAN_TYPE:
return legacy_hal::RTT_PEER_NAN;
};
CHECK(false);
}
legacy_hal::wifi_channel_width convertAidlWifiChannelWidthToLegacy(WifiChannelWidthInMhz type) {
switch (type) {
case WifiChannelWidthInMhz::WIDTH_20:
return legacy_hal::WIFI_CHAN_WIDTH_20;
case WifiChannelWidthInMhz::WIDTH_40:
return legacy_hal::WIFI_CHAN_WIDTH_40;
case WifiChannelWidthInMhz::WIDTH_80:
return legacy_hal::WIFI_CHAN_WIDTH_80;
case WifiChannelWidthInMhz::WIDTH_160:
return legacy_hal::WIFI_CHAN_WIDTH_160;
case WifiChannelWidthInMhz::WIDTH_80P80:
return legacy_hal::WIFI_CHAN_WIDTH_80P80;
case WifiChannelWidthInMhz::WIDTH_5:
return legacy_hal::WIFI_CHAN_WIDTH_5;
case WifiChannelWidthInMhz::WIDTH_10:
return legacy_hal::WIFI_CHAN_WIDTH_10;
case WifiChannelWidthInMhz::WIDTH_320:
return legacy_hal::WIFI_CHAN_WIDTH_320;
case WifiChannelWidthInMhz::WIDTH_INVALID:
return legacy_hal::WIFI_CHAN_WIDTH_INVALID;
};
CHECK(false);
}
WifiChannelWidthInMhz convertLegacyWifiChannelWidthToAidl(legacy_hal::wifi_channel_width type) {
switch (type) {
case legacy_hal::WIFI_CHAN_WIDTH_20:
return WifiChannelWidthInMhz::WIDTH_20;
case legacy_hal::WIFI_CHAN_WIDTH_40:
return WifiChannelWidthInMhz::WIDTH_40;
case legacy_hal::WIFI_CHAN_WIDTH_80:
return WifiChannelWidthInMhz::WIDTH_80;
case legacy_hal::WIFI_CHAN_WIDTH_160:
return WifiChannelWidthInMhz::WIDTH_160;
case legacy_hal::WIFI_CHAN_WIDTH_80P80:
return WifiChannelWidthInMhz::WIDTH_80P80;
case legacy_hal::WIFI_CHAN_WIDTH_5:
return WifiChannelWidthInMhz::WIDTH_5;
case legacy_hal::WIFI_CHAN_WIDTH_10:
return WifiChannelWidthInMhz::WIDTH_10;
case legacy_hal::WIFI_CHAN_WIDTH_320:
return WifiChannelWidthInMhz::WIDTH_320;
default:
return WifiChannelWidthInMhz::WIDTH_INVALID;
};
}
legacy_hal::wifi_rtt_preamble convertAidlRttPreambleToLegacy(RttPreamble type) {
switch (type) {
case RttPreamble::LEGACY:
return legacy_hal::WIFI_RTT_PREAMBLE_LEGACY;
case RttPreamble::HT:
return legacy_hal::WIFI_RTT_PREAMBLE_HT;
case RttPreamble::VHT:
return legacy_hal::WIFI_RTT_PREAMBLE_VHT;
case RttPreamble::HE:
return legacy_hal::WIFI_RTT_PREAMBLE_HE;
case RttPreamble::EHT:
return legacy_hal::WIFI_RTT_PREAMBLE_EHT;
};
CHECK(false);
}
RttPreamble convertLegacyRttPreambleToAidl(legacy_hal::wifi_rtt_preamble type) {
switch (type) {
case legacy_hal::WIFI_RTT_PREAMBLE_LEGACY:
return RttPreamble::LEGACY;
case legacy_hal::WIFI_RTT_PREAMBLE_HT:
return RttPreamble::HT;
case legacy_hal::WIFI_RTT_PREAMBLE_VHT:
return RttPreamble::VHT;
case legacy_hal::WIFI_RTT_PREAMBLE_HE:
return RttPreamble::HE;
case legacy_hal::WIFI_RTT_PREAMBLE_EHT:
return RttPreamble::EHT;
};
CHECK(false) << "Unknown legacy type: " << type;
}
legacy_hal::wifi_rtt_bw convertAidlRttBwToLegacy(RttBw type) {
switch (type) {
case RttBw::BW_5MHZ:
return legacy_hal::WIFI_RTT_BW_5;
case RttBw::BW_10MHZ:
return legacy_hal::WIFI_RTT_BW_10;
case RttBw::BW_20MHZ:
return legacy_hal::WIFI_RTT_BW_20;
case RttBw::BW_40MHZ:
return legacy_hal::WIFI_RTT_BW_40;
case RttBw::BW_80MHZ:
return legacy_hal::WIFI_RTT_BW_80;
case RttBw::BW_160MHZ:
return legacy_hal::WIFI_RTT_BW_160;
case RttBw::BW_320MHZ:
return legacy_hal::WIFI_RTT_BW_320;
case RttBw::BW_UNSPECIFIED:
return legacy_hal::WIFI_RTT_BW_UNSPECIFIED;
};
CHECK(false);
}
RttBw convertLegacyRttBwToAidl(legacy_hal::wifi_rtt_bw type) {
switch (type) {
case legacy_hal::WIFI_RTT_BW_5:
return RttBw::BW_5MHZ;
case legacy_hal::WIFI_RTT_BW_10:
return RttBw::BW_10MHZ;
case legacy_hal::WIFI_RTT_BW_20:
return RttBw::BW_20MHZ;
case legacy_hal::WIFI_RTT_BW_40:
return RttBw::BW_40MHZ;
case legacy_hal::WIFI_RTT_BW_80:
return RttBw::BW_80MHZ;
case legacy_hal::WIFI_RTT_BW_160:
return RttBw::BW_160MHZ;
case legacy_hal::WIFI_RTT_BW_320:
return RttBw::BW_320MHZ;
case legacy_hal::WIFI_RTT_BW_UNSPECIFIED:
return RttBw::BW_UNSPECIFIED;
};
CHECK(false) << "Unknown legacy type: " << type;
}
legacy_hal::wifi_motion_pattern convertAidlRttMotionPatternToLegacy(RttMotionPattern type) {
switch (type) {
case RttMotionPattern::NOT_EXPECTED:
return legacy_hal::WIFI_MOTION_NOT_EXPECTED;
case RttMotionPattern::EXPECTED:
return legacy_hal::WIFI_MOTION_EXPECTED;
case RttMotionPattern::UNKNOWN:
return legacy_hal::WIFI_MOTION_UNKNOWN;
};
CHECK(false);
}
WifiRatePreamble convertLegacyWifiRatePreambleToAidl(uint8_t preamble) {
switch (preamble) {
case 0:
return WifiRatePreamble::OFDM;
case 1:
return WifiRatePreamble::CCK;
case 2:
return WifiRatePreamble::HT;
case 3:
return WifiRatePreamble::VHT;
case 4:
return WifiRatePreamble::HE;
case 5:
return WifiRatePreamble::EHT;
default:
return WifiRatePreamble::RESERVED;
};
CHECK(false) << "Unknown legacy preamble: " << preamble;
}
WifiRateNss convertLegacyWifiRateNssToAidl(uint8_t nss) {
switch (nss) {
case 0:
return WifiRateNss::NSS_1x1;
case 1:
return WifiRateNss::NSS_2x2;
case 2:
return WifiRateNss::NSS_3x3;
case 3:
return WifiRateNss::NSS_4x4;
};
CHECK(false) << "Unknown legacy nss: " << nss;
return {};
}
RttStatus convertLegacyRttStatusToAidl(legacy_hal::wifi_rtt_status status) {
switch (status) {
case legacy_hal::RTT_STATUS_SUCCESS:
return RttStatus::SUCCESS;
case legacy_hal::RTT_STATUS_FAILURE:
return RttStatus::FAILURE;
case legacy_hal::RTT_STATUS_FAIL_NO_RSP:
return RttStatus::FAIL_NO_RSP;
case legacy_hal::RTT_STATUS_FAIL_REJECTED:
return RttStatus::FAIL_REJECTED;
case legacy_hal::RTT_STATUS_FAIL_NOT_SCHEDULED_YET:
return RttStatus::FAIL_NOT_SCHEDULED_YET;
case legacy_hal::RTT_STATUS_FAIL_TM_TIMEOUT:
return RttStatus::FAIL_TM_TIMEOUT;
case legacy_hal::RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL:
return RttStatus::FAIL_AP_ON_DIFF_CHANNEL;
case legacy_hal::RTT_STATUS_FAIL_NO_CAPABILITY:
return RttStatus::FAIL_NO_CAPABILITY;
case legacy_hal::RTT_STATUS_ABORTED:
return RttStatus::ABORTED;
case legacy_hal::RTT_STATUS_FAIL_INVALID_TS:
return RttStatus::FAIL_INVALID_TS;
case legacy_hal::RTT_STATUS_FAIL_PROTOCOL:
return RttStatus::FAIL_PROTOCOL;
case legacy_hal::RTT_STATUS_FAIL_SCHEDULE:
return RttStatus::FAIL_SCHEDULE;
case legacy_hal::RTT_STATUS_FAIL_BUSY_TRY_LATER:
return RttStatus::FAIL_BUSY_TRY_LATER;
case legacy_hal::RTT_STATUS_INVALID_REQ:
return RttStatus::INVALID_REQ;
case legacy_hal::RTT_STATUS_NO_WIFI:
return RttStatus::NO_WIFI;
case legacy_hal::RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE:
return RttStatus::FAIL_FTM_PARAM_OVERRIDE;
case legacy_hal::RTT_STATUS_NAN_RANGING_PROTOCOL_FAILURE:
return RttStatus::NAN_RANGING_PROTOCOL_FAILURE;
case legacy_hal::RTT_STATUS_NAN_RANGING_CONCURRENCY_NOT_SUPPORTED:
return RttStatus::NAN_RANGING_CONCURRENCY_NOT_SUPPORTED;
};
CHECK(false) << "Unknown legacy status: " << status;
}
bool convertAidlWifiChannelInfoToLegacy(const WifiChannelInfo& aidl_info,
legacy_hal::wifi_channel_info* legacy_info) {
if (!legacy_info) {
return false;
}
*legacy_info = {};
legacy_info->width = convertAidlWifiChannelWidthToLegacy(aidl_info.width);
legacy_info->center_freq = aidl_info.centerFreq;
legacy_info->center_freq0 = aidl_info.centerFreq0;
legacy_info->center_freq1 = aidl_info.centerFreq1;
return true;
}
bool convertLegacyWifiChannelInfoToAidl(const legacy_hal::wifi_channel_info& legacy_info,
WifiChannelInfo* aidl_info) {
if (!aidl_info) {
return false;
}
*aidl_info = {};
aidl_info->width = convertLegacyWifiChannelWidthToAidl(legacy_info.width);
aidl_info->centerFreq = legacy_info.center_freq;
aidl_info->centerFreq0 = legacy_info.center_freq0;
aidl_info->centerFreq1 = legacy_info.center_freq1;
return true;
}
bool convertAidlRttConfigToLegacy(const RttConfig& aidl_config,
legacy_hal::wifi_rtt_config* legacy_config) {
if (!legacy_config) {
return false;
}
*legacy_config = {};
CHECK(aidl_config.addr.size() == sizeof(legacy_config->addr));
memcpy(legacy_config->addr, aidl_config.addr.data(), aidl_config.addr.size());
legacy_config->type = convertAidlRttTypeToLegacy(aidl_config.type);
legacy_config->peer = convertAidlRttPeerTypeToLegacy(aidl_config.peer);
if (!convertAidlWifiChannelInfoToLegacy(aidl_config.channel, &legacy_config->channel)) {
return false;
}
legacy_config->burst_period = aidl_config.burstPeriod;
legacy_config->num_burst = aidl_config.numBurst;
legacy_config->num_frames_per_burst = aidl_config.numFramesPerBurst;
legacy_config->num_retries_per_rtt_frame = aidl_config.numRetriesPerRttFrame;
legacy_config->num_retries_per_ftmr = aidl_config.numRetriesPerFtmr;
legacy_config->LCI_request = aidl_config.mustRequestLci;
legacy_config->LCR_request = aidl_config.mustRequestLcr;
legacy_config->burst_duration = aidl_config.burstDuration;
legacy_config->preamble = convertAidlRttPreambleToLegacy(aidl_config.preamble);
legacy_config->bw = convertAidlRttBwToLegacy(aidl_config.bw);
return true;
}
bool convertAidlVectorOfRttConfigToLegacy(
const std::vector<RttConfig>& aidl_configs,
std::vector<legacy_hal::wifi_rtt_config>* legacy_configs) {
if (!legacy_configs) {
return false;
}
*legacy_configs = {};
for (const auto& aidl_config : aidl_configs) {
legacy_hal::wifi_rtt_config legacy_config;
if (!convertAidlRttConfigToLegacy(aidl_config, &legacy_config)) {
return false;
}
legacy_configs->push_back(legacy_config);
}
return true;
}
bool convertAidlRttLciInformationToLegacy(const RttLciInformation& aidl_info,
legacy_hal::wifi_lci_information* legacy_info) {
if (!legacy_info) {
return false;
}
*legacy_info = {};
legacy_info->latitude = aidl_info.latitude;
legacy_info->longitude = aidl_info.longitude;
legacy_info->altitude = aidl_info.altitude;
legacy_info->latitude_unc = aidl_info.latitudeUnc;
legacy_info->longitude_unc = aidl_info.longitudeUnc;
legacy_info->altitude_unc = aidl_info.altitudeUnc;
legacy_info->motion_pattern = convertAidlRttMotionPatternToLegacy(aidl_info.motionPattern);
legacy_info->floor = aidl_info.floor;
legacy_info->height_above_floor = aidl_info.heightAboveFloor;
legacy_info->height_unc = aidl_info.heightUnc;
return true;
}
bool convertAidlRttLcrInformationToLegacy(const RttLcrInformation& aidl_info,
legacy_hal::wifi_lcr_information* legacy_info) {
if (!legacy_info) {
return false;
}
*legacy_info = {};
CHECK(aidl_info.countryCode.size() == sizeof(legacy_info->country_code));
memcpy(legacy_info->country_code, aidl_info.countryCode.data(), aidl_info.countryCode.size());
if (aidl_info.civicInfo.size() > sizeof(legacy_info->civic_info)) {
return false;
}
legacy_info->length = aidl_info.civicInfo.size();
memcpy(legacy_info->civic_info, aidl_info.civicInfo.c_str(), aidl_info.civicInfo.size());
return true;
}
bool convertAidlRttResponderToLegacy(const RttResponder& aidl_responder,
legacy_hal::wifi_rtt_responder* legacy_responder) {
if (!legacy_responder) {
return false;
}
*legacy_responder = {};
if (!convertAidlWifiChannelInfoToLegacy(aidl_responder.channel, &legacy_responder->channel)) {
return false;
}
legacy_responder->preamble = convertAidlRttPreambleToLegacy(aidl_responder.preamble);
return true;
}
bool convertLegacyRttResponderToAidl(const legacy_hal::wifi_rtt_responder& legacy_responder,
RttResponder* aidl_responder) {
if (!aidl_responder) {
return false;
}
*aidl_responder = {};
if (!convertLegacyWifiChannelInfoToAidl(legacy_responder.channel, &aidl_responder->channel)) {
return false;
}
aidl_responder->preamble = convertLegacyRttPreambleToAidl(legacy_responder.preamble);
return true;
}
bool convertLegacyRttCapabilitiesToAidl(
const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
RttCapabilities* aidl_capabilities) {
if (!aidl_capabilities) {
return false;
}
*aidl_capabilities = {};
aidl_capabilities->rttOneSidedSupported = legacy_capabilities.rtt_one_sided_supported;
aidl_capabilities->rttFtmSupported = legacy_capabilities.rtt_ftm_supported;
aidl_capabilities->lciSupported = legacy_capabilities.lci_support;
aidl_capabilities->lcrSupported = legacy_capabilities.lcr_support;
aidl_capabilities->responderSupported = legacy_capabilities.responder_supported;
int32_t preambleSupport = 0;
for (const auto flag : {legacy_hal::WIFI_RTT_PREAMBLE_LEGACY, legacy_hal::WIFI_RTT_PREAMBLE_HT,
legacy_hal::WIFI_RTT_PREAMBLE_VHT, legacy_hal::WIFI_RTT_PREAMBLE_HE,
legacy_hal::WIFI_RTT_PREAMBLE_EHT}) {
if (legacy_capabilities.preamble_support & flag) {
preambleSupport |= static_cast<std::underlying_type<RttPreamble>::type>(
convertLegacyRttPreambleToAidl(flag));
}
}
aidl_capabilities->preambleSupport = static_cast<RttPreamble>(preambleSupport);
int32_t bwSupport = 0;
for (const auto flag :
{legacy_hal::WIFI_RTT_BW_5, legacy_hal::WIFI_RTT_BW_10, legacy_hal::WIFI_RTT_BW_20,
legacy_hal::WIFI_RTT_BW_40, legacy_hal::WIFI_RTT_BW_80, legacy_hal::WIFI_RTT_BW_160,
legacy_hal::WIFI_RTT_BW_320}) {
if (legacy_capabilities.bw_support & flag) {
bwSupport |=
static_cast<std::underlying_type<RttBw>::type>(convertLegacyRttBwToAidl(flag));
}
}
aidl_capabilities->bwSupport = static_cast<RttBw>(bwSupport);
aidl_capabilities->mcVersion = legacy_capabilities.mc_version;
return true;
}
bool convertLegacyWifiRateInfoToAidl(const legacy_hal::wifi_rate& legacy_rate,
WifiRateInfo* aidl_rate) {
if (!aidl_rate) {
return false;
}
*aidl_rate = {};
aidl_rate->preamble = convertLegacyWifiRatePreambleToAidl(legacy_rate.preamble);
aidl_rate->nss = convertLegacyWifiRateNssToAidl(legacy_rate.nss);
aidl_rate->bw = convertLegacyWifiChannelWidthToAidl(
static_cast<legacy_hal::wifi_channel_width>(legacy_rate.bw));
aidl_rate->rateMcsIdx = legacy_rate.rateMcsIdx;
aidl_rate->bitRateInKbps = legacy_rate.bitrate;
return true;
}
bool convertLegacyRttResultToAidl(const legacy_hal::wifi_rtt_result& legacy_result,
RttResult* aidl_result) {
if (!aidl_result) {
return false;
}
*aidl_result = {};
aidl_result->addr = std::array<uint8_t, 6>();
CHECK(sizeof(legacy_result.addr) == aidl_result->addr.size());
std::copy(legacy_result.addr, legacy_result.addr + 6, std::begin(aidl_result->addr));
aidl_result->burstNum = legacy_result.burst_num;
aidl_result->measurementNumber = legacy_result.measurement_number;
aidl_result->successNumber = legacy_result.success_number;
aidl_result->numberPerBurstPeer = legacy_result.number_per_burst_peer;
aidl_result->status = convertLegacyRttStatusToAidl(legacy_result.status);
aidl_result->retryAfterDuration = legacy_result.retry_after_duration;
aidl_result->type = convertLegacyRttTypeToAidl(legacy_result.type);
aidl_result->rssi = legacy_result.rssi;
aidl_result->rssiSpread = legacy_result.rssi_spread;
if (!convertLegacyWifiRateInfoToAidl(legacy_result.tx_rate, &aidl_result->txRate)) {
return false;
}
if (!convertLegacyWifiRateInfoToAidl(legacy_result.rx_rate, &aidl_result->rxRate)) {
return false;
}
aidl_result->rtt = legacy_result.rtt;
aidl_result->rttSd = legacy_result.rtt_sd;
aidl_result->rttSpread = legacy_result.rtt_spread;
aidl_result->distanceInMm = legacy_result.distance_mm;
aidl_result->distanceSdInMm = legacy_result.distance_sd_mm;
aidl_result->distanceSpreadInMm = legacy_result.distance_spread_mm;
aidl_result->timeStampInUs = legacy_result.ts;
aidl_result->burstDurationInMs = legacy_result.burst_duration;
aidl_result->negotiatedBurstNum = legacy_result.negotiated_burst_num;
if (legacy_result.LCI && !convertLegacyIeToAidl(*legacy_result.LCI, &aidl_result->lci)) {
return false;
}
if (legacy_result.LCR && !convertLegacyIeToAidl(*legacy_result.LCR, &aidl_result->lcr)) {
return false;
}
return true;
}
bool convertLegacyVectorOfRttResultToAidl(
const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
std::vector<RttResult>* aidl_results) {
if (!aidl_results) {
return false;
}
*aidl_results = {};
for (const auto legacy_result : legacy_results) {
RttResult aidl_result;
if (!convertLegacyRttResultToAidl(*legacy_result, &aidl_result)) {
return false;
}
aidl_result.channelFreqMHz = 0;
aidl_result.packetBw = RttBw::BW_UNSPECIFIED;
aidl_results->push_back(aidl_result);
}
return true;
}
bool convertLegacyVectorOfRttResultV2ToAidl(
const std::vector<const legacy_hal::wifi_rtt_result_v2*>& legacy_results,
std::vector<RttResult>* aidl_results) {
if (!aidl_results) {
return false;
}
*aidl_results = {};
for (const auto legacy_result : legacy_results) {
RttResult aidl_result;
if (!convertLegacyRttResultToAidl(legacy_result->rtt_result, &aidl_result)) {
return false;
}
aidl_result.channelFreqMHz =
legacy_result->frequency != UNSPECIFIED ? legacy_result->frequency : 0;
aidl_result.packetBw = convertLegacyRttBwToAidl(legacy_result->packet_bw);
aidl_results->push_back(aidl_result);
}
return true;
}
legacy_hal::wifi_interface_type convertAidlIfaceTypeToLegacy(IfaceType aidl_interface_type) {
switch (aidl_interface_type) {
case IfaceType::STA:
return legacy_hal::WIFI_INTERFACE_TYPE_STA;
case IfaceType::AP:
return legacy_hal::WIFI_INTERFACE_TYPE_AP;
case IfaceType::P2P:
return legacy_hal::WIFI_INTERFACE_TYPE_P2P;
case IfaceType::NAN_IFACE:
return legacy_hal::WIFI_INTERFACE_TYPE_NAN;
}
CHECK(false);
}
legacy_hal::wifi_multi_sta_use_case convertAidlMultiStaUseCaseToLegacy(
IWifiChip::MultiStaUseCase use_case) {
switch (use_case) {
case IWifiChip::MultiStaUseCase::DUAL_STA_TRANSIENT_PREFER_PRIMARY:
return legacy_hal::WIFI_DUAL_STA_TRANSIENT_PREFER_PRIMARY;
case IWifiChip::MultiStaUseCase::DUAL_STA_NON_TRANSIENT_UNBIASED:
return legacy_hal::WIFI_DUAL_STA_NON_TRANSIENT_UNBIASED;
}
CHECK(false);
}
bool convertAidlCoexUnsafeChannelToLegacy(
const IWifiChip::CoexUnsafeChannel& aidl_unsafe_channel,
legacy_hal::wifi_coex_unsafe_channel* legacy_unsafe_channel) {
if (!legacy_unsafe_channel) {
return false;
}
*legacy_unsafe_channel = {};
switch (aidl_unsafe_channel.band) {
case WifiBand::BAND_24GHZ:
legacy_unsafe_channel->band = legacy_hal::WLAN_MAC_2_4_BAND;
break;
case WifiBand::BAND_5GHZ:
legacy_unsafe_channel->band = legacy_hal::WLAN_MAC_5_0_BAND;
break;
default:
return false;
};
legacy_unsafe_channel->channel = aidl_unsafe_channel.channel;
legacy_unsafe_channel->power_cap_dbm = aidl_unsafe_channel.powerCapDbm;
return true;
}
bool convertAidlVectorOfCoexUnsafeChannelToLegacy(
const std::vector<IWifiChip::CoexUnsafeChannel>& aidl_unsafe_channels,
std::vector<legacy_hal::wifi_coex_unsafe_channel>* legacy_unsafe_channels) {
if (!legacy_unsafe_channels) {
return false;
}
*legacy_unsafe_channels = {};
for (const auto& aidl_unsafe_channel : aidl_unsafe_channels) {
legacy_hal::wifi_coex_unsafe_channel legacy_unsafe_channel;
if (!aidl_struct_util::convertAidlCoexUnsafeChannelToLegacy(aidl_unsafe_channel,
&legacy_unsafe_channel)) {
return false;
}
legacy_unsafe_channels->push_back(legacy_unsafe_channel);
}
return true;
}
WifiAntennaMode convertLegacyAntennaConfigurationToAidl(uint32_t antenna_cfg) {
switch (antenna_cfg) {
case legacy_hal::WIFI_ANTENNA_1X1:
return WifiAntennaMode::WIFI_ANTENNA_MODE_1X1;
case legacy_hal::WIFI_ANTENNA_2X2:
return WifiAntennaMode::WIFI_ANTENNA_MODE_2X2;
case legacy_hal::WIFI_ANTENNA_3X3:
return WifiAntennaMode::WIFI_ANTENNA_MODE_3X3;
case legacy_hal::WIFI_ANTENNA_4X4:
return WifiAntennaMode::WIFI_ANTENNA_MODE_4X4;
default:
return WifiAntennaMode::WIFI_ANTENNA_MODE_UNSPECIFIED;
}
}
bool convertLegacyWifiRadioConfigurationToAidl(
legacy_hal::wifi_radio_configuration* radio_configuration,
WifiRadioConfiguration* aidl_radio_configuration) {
if (!aidl_radio_configuration) {
return false;
}
*aidl_radio_configuration = {};
aidl_radio_configuration->bandInfo =
aidl_struct_util::convertLegacyMacBandToAidlWifiBand(radio_configuration->band);
if (aidl_radio_configuration->bandInfo == WifiBand::BAND_UNSPECIFIED) {
LOG(ERROR) << "Unspecified band";
return false;
}
aidl_radio_configuration->antennaMode =
aidl_struct_util::convertLegacyAntennaConfigurationToAidl(
radio_configuration->antenna_cfg);
return true;
}
bool convertLegacyRadioCombinationsMatrixToAidl(
legacy_hal::wifi_radio_combination_matrix* legacy_matrix,
WifiRadioCombinationMatrix* aidl_matrix) {
if (!aidl_matrix || !legacy_matrix) {
return false;
}
*aidl_matrix = {};
int num_combinations = legacy_matrix->num_radio_combinations;
std::vector<WifiRadioCombination> radio_combinations_vec;
if (!num_combinations) {
LOG(ERROR) << "zero radio combinations";
return false;
}
wifi_radio_combination* l_radio_combinations_ptr = legacy_matrix->radio_combinations;
for (int i = 0; i < num_combinations; i++) {
int num_configurations = l_radio_combinations_ptr->num_radio_configurations;
WifiRadioCombination radioCombination;
std::vector<WifiRadioConfiguration> radio_configurations_vec;
if (!num_configurations) {
LOG(ERROR) << "zero radio configurations";
return false;
}
for (int j = 0; j < num_configurations; j++) {
WifiRadioConfiguration radioConfiguration;
wifi_radio_configuration* l_radio_configurations_ptr =
&l_radio_combinations_ptr->radio_configurations[j];
if (!aidl_struct_util::convertLegacyWifiRadioConfigurationToAidl(
l_radio_configurations_ptr, &radioConfiguration)) {
LOG(ERROR) << "Error converting wifi radio configuration";
return false;
}
radio_configurations_vec.push_back(radioConfiguration);
}
radioCombination.radioConfigurations = radio_configurations_vec;
radio_combinations_vec.push_back(radioCombination);
l_radio_combinations_ptr =
(wifi_radio_combination*)((u8*)l_radio_combinations_ptr +
sizeof(wifi_radio_combination) +
(sizeof(wifi_radio_configuration) * num_configurations));
}
aidl_matrix->radioCombinations = radio_combinations_vec;
return true;
}
bool convertAidlNanPairingInitiatorRequestToLegacy(const NanPairingRequest& aidl_request,
legacy_hal::NanPairingRequest* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanPairingInitiatorRequestToLegacy: "
"legacy_request is null";
return false;
}
*legacy_request = {};
legacy_request->requestor_instance_id = aidl_request.peerId;
memcpy(legacy_request->peer_disc_mac_addr, aidl_request.peerDiscMacAddr.data(), 6);
legacy_request->nan_pairing_request_type =
convertAidlNanPairingRequestTypeToLegacy(aidl_request.requestType);
legacy_request->enable_pairing_cache = aidl_request.enablePairingCache;
memcpy(legacy_request->nan_identity_key, aidl_request.pairingIdentityKey.data(),
NAN_IDENTITY_KEY_LEN);
legacy_request->is_opportunistic =
aidl_request.securityConfig.securityType == NanPairingSecurityType::OPPORTUNISTIC ? 1
: 0;
legacy_request->akm = convertAidlAkmTypeToLegacy(aidl_request.securityConfig.akm);
if (aidl_request.securityConfig.securityType == NanPairingSecurityType::PMK) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
legacy_request->key_info.body.pmk_info.pmk_len = aidl_request.securityConfig.pmk.size();
if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
LOG(ERROR) << "convertAidlNanPairingInitiatorRequestToLegacy: "
"invalid pmk_len";
return false;
}
memcpy(legacy_request->key_info.body.pmk_info.pmk, aidl_request.securityConfig.pmk.data(),
legacy_request->key_info.body.pmk_info.pmk_len);
}
if (aidl_request.securityConfig.securityType == NanPairingSecurityType::PASSPHRASE) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
legacy_request->key_info.body.passphrase_info.passphrase_len =
aidl_request.securityConfig.passphrase.size();
if (legacy_request->key_info.body.passphrase_info.passphrase_len <
NAN_SECURITY_MIN_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanPairingInitiatorRequestToLegacy: "
"passphrase_len too small";
return false;
}
if (legacy_request->key_info.body.passphrase_info.passphrase_len >
NAN_SECURITY_MAX_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanPairingInitiatorRequestToLegacy: "
"passphrase_len too large";
return false;
}
memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
aidl_request.securityConfig.passphrase.data(),
legacy_request->key_info.body.passphrase_info.passphrase_len);
}
return true;
}
bool convertAidlNanPairingIndicationResponseToLegacy(
const NanRespondToPairingIndicationRequest& aidl_request,
legacy_hal::NanPairingIndicationResponse* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanPairingIndicationResponseToLegacy: "
"legacy_request is null";
return false;
}
*legacy_request = {};
legacy_request->pairing_instance_id = aidl_request.pairingInstanceId;
legacy_request->nan_pairing_request_type =
convertAidlNanPairingRequestTypeToLegacy(aidl_request.requestType);
legacy_request->enable_pairing_cache = aidl_request.enablePairingCache;
memcpy(legacy_request->nan_identity_key, aidl_request.pairingIdentityKey.data(),
NAN_IDENTITY_KEY_LEN);
legacy_request->is_opportunistic =
aidl_request.securityConfig.securityType == NanPairingSecurityType::OPPORTUNISTIC ? 1
: 0;
legacy_request->akm = convertAidlAkmTypeToLegacy(aidl_request.securityConfig.akm);
legacy_request->rsp_code =
aidl_request.acceptRequest ? NAN_PAIRING_REQUEST_ACCEPT : NAN_PAIRING_REQUEST_REJECT;
if (aidl_request.securityConfig.securityType == NanPairingSecurityType::PMK) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
legacy_request->key_info.body.pmk_info.pmk_len = aidl_request.securityConfig.pmk.size();
if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
LOG(ERROR) << "convertAidlNanPairingIndicationResponseToLegacy: "
"invalid pmk_len";
return false;
}
memcpy(legacy_request->key_info.body.pmk_info.pmk, aidl_request.securityConfig.pmk.data(),
legacy_request->key_info.body.pmk_info.pmk_len);
}
if (aidl_request.securityConfig.securityType == NanPairingSecurityType::PASSPHRASE) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
legacy_request->key_info.body.passphrase_info.passphrase_len =
aidl_request.securityConfig.passphrase.size();
if (legacy_request->key_info.body.passphrase_info.passphrase_len <
NAN_SECURITY_MIN_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanPairingIndicationResponseToLegacy: "
"passphrase_len too small";
return false;
}
if (legacy_request->key_info.body.passphrase_info.passphrase_len >
NAN_SECURITY_MAX_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanPairingIndicationResponseToLegacy: "
"passphrase_len too large";
return false;
}
memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
aidl_request.securityConfig.passphrase.data(),
legacy_request->key_info.body.passphrase_info.passphrase_len);
}
return true;
}
bool convertAidlNanBootstrappingInitiatorRequestToLegacy(
const NanBootstrappingRequest& aidl_request,
legacy_hal::NanBootstrappingRequest* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanBootstrappingInitiatorRequestToLegacy: "
"legacy_request is null";
return false;
}
*legacy_request = {};
legacy_request->requestor_instance_id = aidl_request.peerId;
memcpy(legacy_request->peer_disc_mac_addr, aidl_request.peerDiscMacAddr.data(), 6);
legacy_request->request_bootstrapping_method =
convertAidlBootstrappingMethodToLegacy(aidl_request.requestBootstrappingMethod);
return true;
}
bool convertAidlNanBootstrappingIndicationResponseToLegacy(
const NanBootstrappingResponse& aidl_request,
legacy_hal::NanBootstrappingIndicationResponse* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanBootstrappingIndicationResponseToLegacy: "
"legacy_request is null";
return false;
}
*legacy_request = {};
legacy_request->service_instance_id = aidl_request.bootstrappingInstanceId;
legacy_request->rsp_code = aidl_request.acceptRequest ? NAN_BOOTSTRAPPING_REQUEST_ACCEPT
: NAN_BOOTSTRAPPING_REQUEST_REJECT;
return true;
}
bool convertLegacyNanPairingRequestIndToAidl(const legacy_hal::NanPairingRequestInd& legacy_ind,
NanPairingRequestInd* aidl_ind) {
if (!aidl_ind) {
LOG(ERROR) << "convertLegacyNanPairingRequestIndToAidl: aidl_ind is null";
return false;
}
*aidl_ind = {};
aidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
aidl_ind->peerId = legacy_ind.requestor_instance_id;
aidl_ind->peerDiscMacAddr = std::array<uint8_t, 6>();
std::copy(legacy_ind.peer_disc_mac_addr, legacy_ind.peer_disc_mac_addr + 6,
std::begin(aidl_ind->peerDiscMacAddr));
aidl_ind->pairingInstanceId = legacy_ind.pairing_instance_id;
aidl_ind->enablePairingCache = legacy_ind.enable_pairing_cache == 1;
aidl_ind->requestType =
convertLegacyNanPairingRequestTypeToAidl(legacy_ind.nan_pairing_request_type);
if (!convertLegacyNiraToAidl(legacy_ind.nira, &aidl_ind->peerNira)) {
return false;
}
return true;
}
bool convertLegacyNanPairingConfirmIndToAidl(const legacy_hal::NanPairingConfirmInd& legacy_ind,
NanPairingConfirmInd* aidl_ind) {
if (!aidl_ind) {
LOG(ERROR) << "convertLegacyNanPairingRequestIndToAidl: aidl_ind is null";
return false;
}
*aidl_ind = {};
aidl_ind->pairingInstanceId = legacy_ind.pairing_instance_id;
aidl_ind->enablePairingCache = legacy_ind.enable_pairing_cache == 1;
aidl_ind->requestType =
convertLegacyNanPairingRequestTypeToAidl(legacy_ind.nan_pairing_request_type);
aidl_ind->pairingSuccess = legacy_ind.rsp_code == NAN_PAIRING_REQUEST_ACCEPT;
aidl_ind->status.status = convertLegacyNanStatusTypeToAidl(legacy_ind.reason_code);
if (!convertLegacyNpsaToAidl(legacy_ind.npk_security_association, &aidl_ind->npksa)) {
return false;
}
return true;
}
bool convertLegacyNanBootstrappingRequestIndToAidl(
const legacy_hal::NanBootstrappingRequestInd& legacy_ind,
NanBootstrappingRequestInd* aidl_ind) {
if (!aidl_ind) {
LOG(ERROR) << "convertLegacyNanBootstrappingRequestIndToAidl: aidl_ind is null";
return false;
}
*aidl_ind = {};
aidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
aidl_ind->peerId = legacy_ind.requestor_instance_id;
aidl_ind->peerDiscMacAddr = std::array<uint8_t, 6>();
std::copy(legacy_ind.peer_disc_mac_addr, legacy_ind.peer_disc_mac_addr + 6,
std::begin(aidl_ind->peerDiscMacAddr));
aidl_ind->bootstrappingInstanceId = legacy_ind.bootstrapping_instance_id;
aidl_ind->requestBootstrappingMethod =
convertLegacyBootstrappingMethodToAidl(legacy_ind.request_bootstrapping_method);
return true;
}
bool convertLegacyNanBootstrappingConfirmIndToAidl(
const legacy_hal::NanBootstrappingConfirmInd& legacy_ind,
NanBootstrappingConfirmInd* aidl_ind) {
if (!aidl_ind) {
LOG(ERROR) << "convertLegacyNanBootstrappingConfirmIndToAidl: aidl_ind is null";
return false;
}
*aidl_ind = {};
aidl_ind->bootstrappingInstanceId = legacy_ind.bootstrapping_instance_id;
aidl_ind->acceptRequest = legacy_ind.rsp_code == NAN_BOOTSTRAPPING_REQUEST_ACCEPT;
aidl_ind->reasonCode.status = convertLegacyNanStatusTypeToAidl(legacy_ind.reason_code);
return true;
}
bool convertLegacyWifiChipCapabilitiesToAidl(
const legacy_hal::wifi_chip_capabilities& legacy_chip_capabilities,
WifiChipCapabilities& aidl_chip_capabilities) {
aidl_chip_capabilities.maxMloStrLinkCount = legacy_chip_capabilities.max_mlo_str_link_count;
aidl_chip_capabilities.maxConcurrentTdlsSessionCount =
legacy_chip_capabilities.max_concurrent_tdls_session_count;
return true;
}
uint32_t convertAidlChannelCategoryToLegacy(uint32_t aidl_channel_category_mask) {
uint32_t channel_category_mask = 0;
if (aidl_channel_category_mask &
static_cast<int32_t>(IWifiChip::ChannelCategoryMask::INDOOR_CHANNEL)) {
channel_category_mask |= legacy_hal::WIFI_INDOOR_CHANNEL;
}
if (aidl_channel_category_mask &
static_cast<int32_t>(IWifiChip::ChannelCategoryMask::DFS_CHANNEL)) {
channel_category_mask |= legacy_hal::WIFI_DFS_CHANNEL;
}
return channel_category_mask;
}
} // namespace aidl_struct_util
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
Reference in New Issue View Git Blame Copy Permalink