mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
303 lines
7.4 KiB
303 lines
7.4 KiB
// SPDX-License-Identifier: GPL-2.0+ |
|
/* Copyright (c) 2015-2016 Quantenna Communications. All rights reserved. */ |
|
|
|
#include <linux/nl80211.h> |
|
|
|
#include "qlink_util.h" |
|
|
|
u16 qlink_iface_type_to_nl_mask(u16 qlink_type) |
|
{ |
|
u16 result = 0; |
|
|
|
switch (qlink_type) { |
|
case QLINK_IFTYPE_AP: |
|
result |= BIT(NL80211_IFTYPE_AP); |
|
break; |
|
case QLINK_IFTYPE_STATION: |
|
result |= BIT(NL80211_IFTYPE_STATION); |
|
break; |
|
case QLINK_IFTYPE_ADHOC: |
|
result |= BIT(NL80211_IFTYPE_ADHOC); |
|
break; |
|
case QLINK_IFTYPE_MONITOR: |
|
result |= BIT(NL80211_IFTYPE_MONITOR); |
|
break; |
|
case QLINK_IFTYPE_WDS: |
|
result |= BIT(NL80211_IFTYPE_WDS); |
|
break; |
|
case QLINK_IFTYPE_AP_VLAN: |
|
result |= BIT(NL80211_IFTYPE_AP_VLAN); |
|
break; |
|
} |
|
|
|
return result; |
|
} |
|
|
|
u8 qlink_chan_width_mask_to_nl(u16 qlink_mask) |
|
{ |
|
u8 result = 0; |
|
|
|
if (qlink_mask & BIT(QLINK_CHAN_WIDTH_5)) |
|
result |= BIT(NL80211_CHAN_WIDTH_5); |
|
|
|
if (qlink_mask & BIT(QLINK_CHAN_WIDTH_10)) |
|
result |= BIT(NL80211_CHAN_WIDTH_10); |
|
|
|
if (qlink_mask & BIT(QLINK_CHAN_WIDTH_20_NOHT)) |
|
result |= BIT(NL80211_CHAN_WIDTH_20_NOHT); |
|
|
|
if (qlink_mask & BIT(QLINK_CHAN_WIDTH_20)) |
|
result |= BIT(NL80211_CHAN_WIDTH_20); |
|
|
|
if (qlink_mask & BIT(QLINK_CHAN_WIDTH_40)) |
|
result |= BIT(NL80211_CHAN_WIDTH_40); |
|
|
|
if (qlink_mask & BIT(QLINK_CHAN_WIDTH_80)) |
|
result |= BIT(NL80211_CHAN_WIDTH_80); |
|
|
|
if (qlink_mask & BIT(QLINK_CHAN_WIDTH_80P80)) |
|
result |= BIT(NL80211_CHAN_WIDTH_80P80); |
|
|
|
if (qlink_mask & BIT(QLINK_CHAN_WIDTH_160)) |
|
result |= BIT(NL80211_CHAN_WIDTH_160); |
|
|
|
return result; |
|
} |
|
|
|
static enum nl80211_chan_width qlink_chanwidth_to_nl(u8 qlw) |
|
{ |
|
switch (qlw) { |
|
case QLINK_CHAN_WIDTH_20_NOHT: |
|
return NL80211_CHAN_WIDTH_20_NOHT; |
|
case QLINK_CHAN_WIDTH_20: |
|
return NL80211_CHAN_WIDTH_20; |
|
case QLINK_CHAN_WIDTH_40: |
|
return NL80211_CHAN_WIDTH_40; |
|
case QLINK_CHAN_WIDTH_80: |
|
return NL80211_CHAN_WIDTH_80; |
|
case QLINK_CHAN_WIDTH_80P80: |
|
return NL80211_CHAN_WIDTH_80P80; |
|
case QLINK_CHAN_WIDTH_160: |
|
return NL80211_CHAN_WIDTH_160; |
|
case QLINK_CHAN_WIDTH_5: |
|
return NL80211_CHAN_WIDTH_5; |
|
case QLINK_CHAN_WIDTH_10: |
|
return NL80211_CHAN_WIDTH_10; |
|
default: |
|
return -1; |
|
} |
|
} |
|
|
|
static u8 qlink_chanwidth_nl_to_qlink(enum nl80211_chan_width nlwidth) |
|
{ |
|
switch (nlwidth) { |
|
case NL80211_CHAN_WIDTH_20_NOHT: |
|
return QLINK_CHAN_WIDTH_20_NOHT; |
|
case NL80211_CHAN_WIDTH_20: |
|
return QLINK_CHAN_WIDTH_20; |
|
case NL80211_CHAN_WIDTH_40: |
|
return QLINK_CHAN_WIDTH_40; |
|
case NL80211_CHAN_WIDTH_80: |
|
return QLINK_CHAN_WIDTH_80; |
|
case NL80211_CHAN_WIDTH_80P80: |
|
return QLINK_CHAN_WIDTH_80P80; |
|
case NL80211_CHAN_WIDTH_160: |
|
return QLINK_CHAN_WIDTH_160; |
|
case NL80211_CHAN_WIDTH_5: |
|
return QLINK_CHAN_WIDTH_5; |
|
case NL80211_CHAN_WIDTH_10: |
|
return QLINK_CHAN_WIDTH_10; |
|
default: |
|
return -1; |
|
} |
|
} |
|
|
|
void qlink_chandef_q2cfg(struct wiphy *wiphy, |
|
const struct qlink_chandef *qch, |
|
struct cfg80211_chan_def *chdef) |
|
{ |
|
struct ieee80211_channel *chan; |
|
|
|
chan = ieee80211_get_channel(wiphy, le16_to_cpu(qch->chan.center_freq)); |
|
|
|
chdef->chan = chan; |
|
chdef->center_freq1 = le16_to_cpu(qch->center_freq1); |
|
chdef->center_freq2 = le16_to_cpu(qch->center_freq2); |
|
chdef->width = qlink_chanwidth_to_nl(qch->width); |
|
chdef->edmg.bw_config = 0; |
|
chdef->edmg.channels = 0; |
|
} |
|
|
|
void qlink_chandef_cfg2q(const struct cfg80211_chan_def *chdef, |
|
struct qlink_chandef *qch) |
|
{ |
|
struct ieee80211_channel *chan = chdef->chan; |
|
|
|
qch->chan.hw_value = cpu_to_le16(chan->hw_value); |
|
qch->chan.center_freq = cpu_to_le16(chan->center_freq); |
|
qch->chan.flags = cpu_to_le32(chan->flags); |
|
|
|
qch->center_freq1 = cpu_to_le16(chdef->center_freq1); |
|
qch->center_freq2 = cpu_to_le16(chdef->center_freq2); |
|
qch->width = qlink_chanwidth_nl_to_qlink(chdef->width); |
|
} |
|
|
|
enum qlink_hidden_ssid qlink_hidden_ssid_nl2q(enum nl80211_hidden_ssid nl_val) |
|
{ |
|
switch (nl_val) { |
|
case NL80211_HIDDEN_SSID_ZERO_LEN: |
|
return QLINK_HIDDEN_SSID_ZERO_LEN; |
|
case NL80211_HIDDEN_SSID_ZERO_CONTENTS: |
|
return QLINK_HIDDEN_SSID_ZERO_CONTENTS; |
|
case NL80211_HIDDEN_SSID_NOT_IN_USE: |
|
default: |
|
return QLINK_HIDDEN_SSID_NOT_IN_USE; |
|
} |
|
} |
|
|
|
bool qtnf_utils_is_bit_set(const u8 *arr, unsigned int bit, |
|
unsigned int arr_max_len) |
|
{ |
|
unsigned int idx = bit / BITS_PER_BYTE; |
|
u8 mask = 1 << (bit - (idx * BITS_PER_BYTE)); |
|
|
|
if (idx >= arr_max_len) |
|
return false; |
|
|
|
return arr[idx] & mask; |
|
} |
|
|
|
void qlink_acl_data_cfg2q(const struct cfg80211_acl_data *acl, |
|
struct qlink_acl_data *qacl) |
|
{ |
|
switch (acl->acl_policy) { |
|
case NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED: |
|
qacl->policy = |
|
cpu_to_le32(QLINK_ACL_POLICY_ACCEPT_UNLESS_LISTED); |
|
break; |
|
case NL80211_ACL_POLICY_DENY_UNLESS_LISTED: |
|
qacl->policy = cpu_to_le32(QLINK_ACL_POLICY_DENY_UNLESS_LISTED); |
|
break; |
|
} |
|
|
|
qacl->num_entries = cpu_to_le32(acl->n_acl_entries); |
|
memcpy(qacl->mac_addrs, acl->mac_addrs, |
|
acl->n_acl_entries * sizeof(*qacl->mac_addrs)); |
|
} |
|
|
|
enum qlink_band qlink_utils_band_cfg2q(enum nl80211_band band) |
|
{ |
|
switch (band) { |
|
case NL80211_BAND_2GHZ: |
|
return QLINK_BAND_2GHZ; |
|
case NL80211_BAND_5GHZ: |
|
return QLINK_BAND_5GHZ; |
|
case NL80211_BAND_60GHZ: |
|
return QLINK_BAND_60GHZ; |
|
default: |
|
return -EINVAL; |
|
} |
|
} |
|
|
|
enum qlink_dfs_state qlink_utils_dfs_state_cfg2q(enum nl80211_dfs_state state) |
|
{ |
|
switch (state) { |
|
case NL80211_DFS_USABLE: |
|
return QLINK_DFS_USABLE; |
|
case NL80211_DFS_AVAILABLE: |
|
return QLINK_DFS_AVAILABLE; |
|
case NL80211_DFS_UNAVAILABLE: |
|
default: |
|
return QLINK_DFS_UNAVAILABLE; |
|
} |
|
} |
|
|
|
u32 qlink_utils_chflags_cfg2q(u32 cfgflags) |
|
{ |
|
u32 flags = 0; |
|
|
|
if (cfgflags & IEEE80211_CHAN_DISABLED) |
|
flags |= QLINK_CHAN_DISABLED; |
|
|
|
if (cfgflags & IEEE80211_CHAN_NO_IR) |
|
flags |= QLINK_CHAN_NO_IR; |
|
|
|
if (cfgflags & IEEE80211_CHAN_RADAR) |
|
flags |= QLINK_CHAN_RADAR; |
|
|
|
if (cfgflags & IEEE80211_CHAN_NO_HT40PLUS) |
|
flags |= QLINK_CHAN_NO_HT40PLUS; |
|
|
|
if (cfgflags & IEEE80211_CHAN_NO_HT40MINUS) |
|
flags |= QLINK_CHAN_NO_HT40MINUS; |
|
|
|
if (cfgflags & IEEE80211_CHAN_NO_80MHZ) |
|
flags |= QLINK_CHAN_NO_80MHZ; |
|
|
|
if (cfgflags & IEEE80211_CHAN_NO_160MHZ) |
|
flags |= QLINK_CHAN_NO_160MHZ; |
|
|
|
return flags; |
|
} |
|
|
|
static u32 qtnf_reg_rule_flags_parse(u32 qflags) |
|
{ |
|
u32 flags = 0; |
|
|
|
if (qflags & QLINK_RRF_NO_OFDM) |
|
flags |= NL80211_RRF_NO_OFDM; |
|
|
|
if (qflags & QLINK_RRF_NO_CCK) |
|
flags |= NL80211_RRF_NO_CCK; |
|
|
|
if (qflags & QLINK_RRF_NO_INDOOR) |
|
flags |= NL80211_RRF_NO_INDOOR; |
|
|
|
if (qflags & QLINK_RRF_NO_OUTDOOR) |
|
flags |= NL80211_RRF_NO_OUTDOOR; |
|
|
|
if (qflags & QLINK_RRF_DFS) |
|
flags |= NL80211_RRF_DFS; |
|
|
|
if (qflags & QLINK_RRF_PTP_ONLY) |
|
flags |= NL80211_RRF_PTP_ONLY; |
|
|
|
if (qflags & QLINK_RRF_PTMP_ONLY) |
|
flags |= NL80211_RRF_PTMP_ONLY; |
|
|
|
if (qflags & QLINK_RRF_NO_IR) |
|
flags |= NL80211_RRF_NO_IR; |
|
|
|
if (qflags & QLINK_RRF_AUTO_BW) |
|
flags |= NL80211_RRF_AUTO_BW; |
|
|
|
if (qflags & QLINK_RRF_IR_CONCURRENT) |
|
flags |= NL80211_RRF_IR_CONCURRENT; |
|
|
|
if (qflags & QLINK_RRF_NO_HT40MINUS) |
|
flags |= NL80211_RRF_NO_HT40MINUS; |
|
|
|
if (qflags & QLINK_RRF_NO_HT40PLUS) |
|
flags |= NL80211_RRF_NO_HT40PLUS; |
|
|
|
if (qflags & QLINK_RRF_NO_80MHZ) |
|
flags |= NL80211_RRF_NO_80MHZ; |
|
|
|
if (qflags & QLINK_RRF_NO_160MHZ) |
|
flags |= NL80211_RRF_NO_160MHZ; |
|
|
|
return flags; |
|
} |
|
|
|
void qlink_utils_regrule_q2nl(struct ieee80211_reg_rule *rule, |
|
const struct qlink_tlv_reg_rule *tlv) |
|
{ |
|
rule->freq_range.start_freq_khz = le32_to_cpu(tlv->start_freq_khz); |
|
rule->freq_range.end_freq_khz = le32_to_cpu(tlv->end_freq_khz); |
|
rule->freq_range.max_bandwidth_khz = |
|
le32_to_cpu(tlv->max_bandwidth_khz); |
|
rule->power_rule.max_antenna_gain = le32_to_cpu(tlv->max_antenna_gain); |
|
rule->power_rule.max_eirp = le32_to_cpu(tlv->max_eirp); |
|
rule->dfs_cac_ms = le32_to_cpu(tlv->dfs_cac_ms); |
|
rule->flags = qtnf_reg_rule_flags_parse(le32_to_cpu(tlv->flags)); |
|
}
|
|
|