mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-05 22:06:49 +07:00
237f83dfbe
Pull networking updates from David Miller: "Some highlights from this development cycle: 1) Big refactoring of ipv6 route and neigh handling to support nexthop objects configurable as units from userspace. From David Ahern. 2) Convert explored_states in BPF verifier into a hash table, significantly decreased state held for programs with bpf2bpf calls, from Alexei Starovoitov. 3) Implement bpf_send_signal() helper, from Yonghong Song. 4) Various classifier enhancements to mvpp2 driver, from Maxime Chevallier. 5) Add aRFS support to hns3 driver, from Jian Shen. 6) Fix use after free in inet frags by allocating fqdirs dynamically and reworking how rhashtable dismantle occurs, from Eric Dumazet. 7) Add act_ctinfo packet classifier action, from Kevin Darbyshire-Bryant. 8) Add TFO key backup infrastructure, from Jason Baron. 9) Remove several old and unused ISDN drivers, from Arnd Bergmann. 10) Add devlink notifications for flash update status to mlxsw driver, from Jiri Pirko. 11) Lots of kTLS offload infrastructure fixes, from Jakub Kicinski. 12) Add support for mv88e6250 DSA chips, from Rasmus Villemoes. 13) Various enhancements to ipv6 flow label handling, from Eric Dumazet and Willem de Bruijn. 14) Support TLS offload in nfp driver, from Jakub Kicinski, Dirk van der Merwe, and others. 15) Various improvements to axienet driver including converting it to phylink, from Robert Hancock. 16) Add PTP support to sja1105 DSA driver, from Vladimir Oltean. 17) Add mqprio qdisc offload support to dpaa2-eth, from Ioana Radulescu. 18) Add devlink health reporting to mlx5, from Moshe Shemesh. 19) Convert stmmac over to phylink, from Jose Abreu. 20) Add PTP PHC (Physical Hardware Clock) support to mlxsw, from Shalom Toledo. 21) Add nftables SYNPROXY support, from Fernando Fernandez Mancera. 22) Convert tcp_fastopen over to use SipHash, from Ard Biesheuvel. 23) Track spill/fill of constants in BPF verifier, from Alexei Starovoitov. 24) Support bounded loops in BPF, from Alexei Starovoitov. 25) Various page_pool API fixes and improvements, from Jesper Dangaard Brouer. 26) Just like ipv4, support ref-countless ipv6 route handling. From Wei Wang. 27) Support VLAN offloading in aquantia driver, from Igor Russkikh. 28) Add AF_XDP zero-copy support to mlx5, from Maxim Mikityanskiy. 29) Add flower GRE encap/decap support to nfp driver, from Pieter Jansen van Vuuren. 30) Protect against stack overflow when using act_mirred, from John Hurley. 31) Allow devmap map lookups from eBPF, from Toke Høiland-Jørgensen. 32) Use page_pool API in netsec driver, Ilias Apalodimas. 33) Add Google gve network driver, from Catherine Sullivan. 34) More indirect call avoidance, from Paolo Abeni. 35) Add kTLS TX HW offload support to mlx5, from Tariq Toukan. 36) Add XDP_REDIRECT support to bnxt_en, from Andy Gospodarek. 37) Add MPLS manipulation actions to TC, from John Hurley. 38) Add sending a packet to connection tracking from TC actions, and then allow flower classifier matching on conntrack state. From Paul Blakey. 39) Netfilter hw offload support, from Pablo Neira Ayuso" * git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next: (2080 commits) net/mlx5e: Return in default case statement in tx_post_resync_params mlx5: Return -EINVAL when WARN_ON_ONCE triggers in mlx5e_tls_resync(). net: dsa: add support for BRIDGE_MROUTER attribute pkt_sched: Include const.h net: netsec: remove static declaration for netsec_set_tx_de() net: netsec: remove superfluous if statement netfilter: nf_tables: add hardware offload support net: flow_offload: rename tc_cls_flower_offload to flow_cls_offload net: flow_offload: add flow_block_cb_is_busy() and use it net: sched: remove tcf block API drivers: net: use flow block API net: sched: use flow block API net: flow_offload: add flow_block_cb_{priv, incref, decref}() net: flow_offload: add list handling functions net: flow_offload: add flow_block_cb_alloc() and flow_block_cb_free() net: flow_offload: rename TCF_BLOCK_BINDER_TYPE_* to FLOW_BLOCK_BINDER_TYPE_* net: flow_offload: rename TC_BLOCK_{UN}BIND to FLOW_BLOCK_{UN}BIND net: flow_offload: add flow_block_cb_setup_simple() net: hisilicon: Add an tx_desc to adapt HI13X1_GMAC net: hisilicon: Add an rx_desc to adapt HI13X1_GMAC ...
1439 lines
40 KiB
C
1439 lines
40 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Copyright 2002-2005, Instant802 Networks, Inc.
|
|
* Copyright 2005-2006, Devicescape Software, Inc.
|
|
* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
|
|
* Copyright 2013-2014 Intel Mobile Communications GmbH
|
|
* Copyright (C) 2017 Intel Deutschland GmbH
|
|
* Copyright (C) 2018 - 2019 Intel Corporation
|
|
*/
|
|
|
|
#include <net/mac80211.h>
|
|
#include <linux/module.h>
|
|
#include <linux/fips.h>
|
|
#include <linux/init.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/types.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/if_arp.h>
|
|
#include <linux/rtnetlink.h>
|
|
#include <linux/bitmap.h>
|
|
#include <linux/inetdevice.h>
|
|
#include <net/net_namespace.h>
|
|
#include <net/cfg80211.h>
|
|
#include <net/addrconf.h>
|
|
|
|
#include "ieee80211_i.h"
|
|
#include "driver-ops.h"
|
|
#include "rate.h"
|
|
#include "mesh.h"
|
|
#include "wep.h"
|
|
#include "led.h"
|
|
#include "debugfs.h"
|
|
|
|
void ieee80211_configure_filter(struct ieee80211_local *local)
|
|
{
|
|
u64 mc;
|
|
unsigned int changed_flags;
|
|
unsigned int new_flags = 0;
|
|
|
|
if (atomic_read(&local->iff_allmultis))
|
|
new_flags |= FIF_ALLMULTI;
|
|
|
|
if (local->monitors || test_bit(SCAN_SW_SCANNING, &local->scanning) ||
|
|
test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning))
|
|
new_flags |= FIF_BCN_PRBRESP_PROMISC;
|
|
|
|
if (local->fif_probe_req || local->probe_req_reg)
|
|
new_flags |= FIF_PROBE_REQ;
|
|
|
|
if (local->fif_fcsfail)
|
|
new_flags |= FIF_FCSFAIL;
|
|
|
|
if (local->fif_plcpfail)
|
|
new_flags |= FIF_PLCPFAIL;
|
|
|
|
if (local->fif_control)
|
|
new_flags |= FIF_CONTROL;
|
|
|
|
if (local->fif_other_bss)
|
|
new_flags |= FIF_OTHER_BSS;
|
|
|
|
if (local->fif_pspoll)
|
|
new_flags |= FIF_PSPOLL;
|
|
|
|
spin_lock_bh(&local->filter_lock);
|
|
changed_flags = local->filter_flags ^ new_flags;
|
|
|
|
mc = drv_prepare_multicast(local, &local->mc_list);
|
|
spin_unlock_bh(&local->filter_lock);
|
|
|
|
/* be a bit nasty */
|
|
new_flags |= (1<<31);
|
|
|
|
drv_configure_filter(local, changed_flags, &new_flags, mc);
|
|
|
|
WARN_ON(new_flags & (1<<31));
|
|
|
|
local->filter_flags = new_flags & ~(1<<31);
|
|
}
|
|
|
|
static void ieee80211_reconfig_filter(struct work_struct *work)
|
|
{
|
|
struct ieee80211_local *local =
|
|
container_of(work, struct ieee80211_local, reconfig_filter);
|
|
|
|
ieee80211_configure_filter(local);
|
|
}
|
|
|
|
static u32 ieee80211_hw_conf_chan(struct ieee80211_local *local)
|
|
{
|
|
struct ieee80211_sub_if_data *sdata;
|
|
struct cfg80211_chan_def chandef = {};
|
|
u32 changed = 0;
|
|
int power;
|
|
u32 offchannel_flag;
|
|
|
|
offchannel_flag = local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL;
|
|
|
|
if (local->scan_chandef.chan) {
|
|
chandef = local->scan_chandef;
|
|
} else if (local->tmp_channel) {
|
|
chandef.chan = local->tmp_channel;
|
|
chandef.width = NL80211_CHAN_WIDTH_20_NOHT;
|
|
chandef.center_freq1 = chandef.chan->center_freq;
|
|
} else
|
|
chandef = local->_oper_chandef;
|
|
|
|
WARN(!cfg80211_chandef_valid(&chandef),
|
|
"control:%d MHz width:%d center: %d/%d MHz",
|
|
chandef.chan->center_freq, chandef.width,
|
|
chandef.center_freq1, chandef.center_freq2);
|
|
|
|
if (!cfg80211_chandef_identical(&chandef, &local->_oper_chandef))
|
|
local->hw.conf.flags |= IEEE80211_CONF_OFFCHANNEL;
|
|
else
|
|
local->hw.conf.flags &= ~IEEE80211_CONF_OFFCHANNEL;
|
|
|
|
offchannel_flag ^= local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL;
|
|
|
|
if (offchannel_flag ||
|
|
!cfg80211_chandef_identical(&local->hw.conf.chandef,
|
|
&local->_oper_chandef)) {
|
|
local->hw.conf.chandef = chandef;
|
|
changed |= IEEE80211_CONF_CHANGE_CHANNEL;
|
|
}
|
|
|
|
if (!conf_is_ht(&local->hw.conf)) {
|
|
/*
|
|
* mac80211.h documents that this is only valid
|
|
* when the channel is set to an HT type, and
|
|
* that otherwise STATIC is used.
|
|
*/
|
|
local->hw.conf.smps_mode = IEEE80211_SMPS_STATIC;
|
|
} else if (local->hw.conf.smps_mode != local->smps_mode) {
|
|
local->hw.conf.smps_mode = local->smps_mode;
|
|
changed |= IEEE80211_CONF_CHANGE_SMPS;
|
|
}
|
|
|
|
power = ieee80211_chandef_max_power(&chandef);
|
|
|
|
rcu_read_lock();
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
|
if (!rcu_access_pointer(sdata->vif.chanctx_conf))
|
|
continue;
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
|
|
continue;
|
|
power = min(power, sdata->vif.bss_conf.txpower);
|
|
}
|
|
rcu_read_unlock();
|
|
|
|
if (local->hw.conf.power_level != power) {
|
|
changed |= IEEE80211_CONF_CHANGE_POWER;
|
|
local->hw.conf.power_level = power;
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
int ieee80211_hw_config(struct ieee80211_local *local, u32 changed)
|
|
{
|
|
int ret = 0;
|
|
|
|
might_sleep();
|
|
|
|
if (!local->use_chanctx)
|
|
changed |= ieee80211_hw_conf_chan(local);
|
|
else
|
|
changed &= ~(IEEE80211_CONF_CHANGE_CHANNEL |
|
|
IEEE80211_CONF_CHANGE_POWER);
|
|
|
|
if (changed && local->open_count) {
|
|
ret = drv_config(local, changed);
|
|
/*
|
|
* Goal:
|
|
* HW reconfiguration should never fail, the driver has told
|
|
* us what it can support so it should live up to that promise.
|
|
*
|
|
* Current status:
|
|
* rfkill is not integrated with mac80211 and a
|
|
* configuration command can thus fail if hardware rfkill
|
|
* is enabled
|
|
*
|
|
* FIXME: integrate rfkill with mac80211 and then add this
|
|
* WARN_ON() back
|
|
*
|
|
*/
|
|
/* WARN_ON(ret); */
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
|
|
u32 changed)
|
|
{
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
if (!changed || sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
|
|
return;
|
|
|
|
drv_bss_info_changed(local, sdata, &sdata->vif.bss_conf, changed);
|
|
}
|
|
|
|
u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
|
|
{
|
|
sdata->vif.bss_conf.use_cts_prot = false;
|
|
sdata->vif.bss_conf.use_short_preamble = false;
|
|
sdata->vif.bss_conf.use_short_slot = false;
|
|
return BSS_CHANGED_ERP_CTS_PROT |
|
|
BSS_CHANGED_ERP_PREAMBLE |
|
|
BSS_CHANGED_ERP_SLOT;
|
|
}
|
|
|
|
static void ieee80211_tasklet_handler(unsigned long data)
|
|
{
|
|
struct ieee80211_local *local = (struct ieee80211_local *) data;
|
|
struct sk_buff *skb;
|
|
|
|
while ((skb = skb_dequeue(&local->skb_queue)) ||
|
|
(skb = skb_dequeue(&local->skb_queue_unreliable))) {
|
|
switch (skb->pkt_type) {
|
|
case IEEE80211_RX_MSG:
|
|
/* Clear skb->pkt_type in order to not confuse kernel
|
|
* netstack. */
|
|
skb->pkt_type = 0;
|
|
ieee80211_rx(&local->hw, skb);
|
|
break;
|
|
case IEEE80211_TX_STATUS_MSG:
|
|
skb->pkt_type = 0;
|
|
ieee80211_tx_status(&local->hw, skb);
|
|
break;
|
|
default:
|
|
WARN(1, "mac80211: Packet is of unknown type %d\n",
|
|
skb->pkt_type);
|
|
dev_kfree_skb(skb);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ieee80211_restart_work(struct work_struct *work)
|
|
{
|
|
struct ieee80211_local *local =
|
|
container_of(work, struct ieee80211_local, restart_work);
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
/* wait for scan work complete */
|
|
flush_workqueue(local->workqueue);
|
|
flush_work(&local->sched_scan_stopped_work);
|
|
|
|
WARN(test_bit(SCAN_HW_SCANNING, &local->scanning),
|
|
"%s called with hardware scan in progress\n", __func__);
|
|
|
|
flush_work(&local->radar_detected_work);
|
|
rtnl_lock();
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
/*
|
|
* XXX: there may be more work for other vif types and even
|
|
* for station mode: a good thing would be to run most of
|
|
* the iface type's dependent _stop (ieee80211_mg_stop,
|
|
* ieee80211_ibss_stop) etc...
|
|
* For now, fix only the specific bug that was seen: race
|
|
* between csa_connection_drop_work and us.
|
|
*/
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION) {
|
|
/*
|
|
* This worker is scheduled from the iface worker that
|
|
* runs on mac80211's workqueue, so we can't be
|
|
* scheduling this worker after the cancel right here.
|
|
* The exception is ieee80211_chswitch_done.
|
|
* Then we can have a race...
|
|
*/
|
|
cancel_work_sync(&sdata->u.mgd.csa_connection_drop_work);
|
|
}
|
|
flush_delayed_work(&sdata->dec_tailroom_needed_wk);
|
|
}
|
|
ieee80211_scan_cancel(local);
|
|
|
|
/* make sure any new ROC will consider local->in_reconfig */
|
|
flush_delayed_work(&local->roc_work);
|
|
flush_work(&local->hw_roc_done);
|
|
|
|
/* wait for all packet processing to be done */
|
|
synchronize_net();
|
|
|
|
ieee80211_reconfig(local);
|
|
rtnl_unlock();
|
|
}
|
|
|
|
void ieee80211_restart_hw(struct ieee80211_hw *hw)
|
|
{
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
trace_api_restart_hw(local);
|
|
|
|
wiphy_info(hw->wiphy,
|
|
"Hardware restart was requested\n");
|
|
|
|
/* use this reason, ieee80211_reconfig will unblock it */
|
|
ieee80211_stop_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
|
|
IEEE80211_QUEUE_STOP_REASON_SUSPEND,
|
|
false);
|
|
|
|
/*
|
|
* Stop all Rx during the reconfig. We don't want state changes
|
|
* or driver callbacks while this is in progress.
|
|
*/
|
|
local->in_reconfig = true;
|
|
barrier();
|
|
|
|
queue_work(system_freezable_wq, &local->restart_work);
|
|
}
|
|
EXPORT_SYMBOL(ieee80211_restart_hw);
|
|
|
|
#ifdef CONFIG_INET
|
|
static int ieee80211_ifa_changed(struct notifier_block *nb,
|
|
unsigned long data, void *arg)
|
|
{
|
|
struct in_ifaddr *ifa = arg;
|
|
struct ieee80211_local *local =
|
|
container_of(nb, struct ieee80211_local,
|
|
ifa_notifier);
|
|
struct net_device *ndev = ifa->ifa_dev->dev;
|
|
struct wireless_dev *wdev = ndev->ieee80211_ptr;
|
|
struct in_device *idev;
|
|
struct ieee80211_sub_if_data *sdata;
|
|
struct ieee80211_bss_conf *bss_conf;
|
|
struct ieee80211_if_managed *ifmgd;
|
|
int c = 0;
|
|
|
|
/* Make sure it's our interface that got changed */
|
|
if (!wdev)
|
|
return NOTIFY_DONE;
|
|
|
|
if (wdev->wiphy != local->hw.wiphy)
|
|
return NOTIFY_DONE;
|
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(ndev);
|
|
bss_conf = &sdata->vif.bss_conf;
|
|
|
|
/* ARP filtering is only supported in managed mode */
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION)
|
|
return NOTIFY_DONE;
|
|
|
|
idev = __in_dev_get_rtnl(sdata->dev);
|
|
if (!idev)
|
|
return NOTIFY_DONE;
|
|
|
|
ifmgd = &sdata->u.mgd;
|
|
sdata_lock(sdata);
|
|
|
|
/* Copy the addresses to the bss_conf list */
|
|
ifa = rtnl_dereference(idev->ifa_list);
|
|
while (ifa) {
|
|
if (c < IEEE80211_BSS_ARP_ADDR_LIST_LEN)
|
|
bss_conf->arp_addr_list[c] = ifa->ifa_address;
|
|
ifa = rtnl_dereference(ifa->ifa_next);
|
|
c++;
|
|
}
|
|
|
|
bss_conf->arp_addr_cnt = c;
|
|
|
|
/* Configure driver only if associated (which also implies it is up) */
|
|
if (ifmgd->associated)
|
|
ieee80211_bss_info_change_notify(sdata,
|
|
BSS_CHANGED_ARP_FILTER);
|
|
|
|
sdata_unlock(sdata);
|
|
|
|
return NOTIFY_OK;
|
|
}
|
|
#endif
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
static int ieee80211_ifa6_changed(struct notifier_block *nb,
|
|
unsigned long data, void *arg)
|
|
{
|
|
struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)arg;
|
|
struct inet6_dev *idev = ifa->idev;
|
|
struct net_device *ndev = ifa->idev->dev;
|
|
struct ieee80211_local *local =
|
|
container_of(nb, struct ieee80211_local, ifa6_notifier);
|
|
struct wireless_dev *wdev = ndev->ieee80211_ptr;
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
/* Make sure it's our interface that got changed */
|
|
if (!wdev || wdev->wiphy != local->hw.wiphy)
|
|
return NOTIFY_DONE;
|
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(ndev);
|
|
|
|
/*
|
|
* For now only support station mode. This is mostly because
|
|
* doing AP would have to handle AP_VLAN in some way ...
|
|
*/
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION)
|
|
return NOTIFY_DONE;
|
|
|
|
drv_ipv6_addr_change(local, sdata, idev);
|
|
|
|
return NOTIFY_OK;
|
|
}
|
|
#endif
|
|
|
|
/* There isn't a lot of sense in it, but you can transmit anything you like */
|
|
static const struct ieee80211_txrx_stypes
|
|
ieee80211_default_mgmt_stypes[NUM_NL80211_IFTYPES] = {
|
|
[NL80211_IFTYPE_ADHOC] = {
|
|
.tx = 0xffff,
|
|
.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
|
|
BIT(IEEE80211_STYPE_AUTH >> 4) |
|
|
BIT(IEEE80211_STYPE_DEAUTH >> 4) |
|
|
BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
|
|
},
|
|
[NL80211_IFTYPE_STATION] = {
|
|
.tx = 0xffff,
|
|
.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
|
|
BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
|
|
},
|
|
[NL80211_IFTYPE_AP] = {
|
|
.tx = 0xffff,
|
|
.rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
|
|
BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
|
|
BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
|
|
BIT(IEEE80211_STYPE_DISASSOC >> 4) |
|
|
BIT(IEEE80211_STYPE_AUTH >> 4) |
|
|
BIT(IEEE80211_STYPE_DEAUTH >> 4) |
|
|
BIT(IEEE80211_STYPE_ACTION >> 4),
|
|
},
|
|
[NL80211_IFTYPE_AP_VLAN] = {
|
|
/* copy AP */
|
|
.tx = 0xffff,
|
|
.rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
|
|
BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
|
|
BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
|
|
BIT(IEEE80211_STYPE_DISASSOC >> 4) |
|
|
BIT(IEEE80211_STYPE_AUTH >> 4) |
|
|
BIT(IEEE80211_STYPE_DEAUTH >> 4) |
|
|
BIT(IEEE80211_STYPE_ACTION >> 4),
|
|
},
|
|
[NL80211_IFTYPE_P2P_CLIENT] = {
|
|
.tx = 0xffff,
|
|
.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
|
|
BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
|
|
},
|
|
[NL80211_IFTYPE_P2P_GO] = {
|
|
.tx = 0xffff,
|
|
.rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
|
|
BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
|
|
BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
|
|
BIT(IEEE80211_STYPE_DISASSOC >> 4) |
|
|
BIT(IEEE80211_STYPE_AUTH >> 4) |
|
|
BIT(IEEE80211_STYPE_DEAUTH >> 4) |
|
|
BIT(IEEE80211_STYPE_ACTION >> 4),
|
|
},
|
|
[NL80211_IFTYPE_MESH_POINT] = {
|
|
.tx = 0xffff,
|
|
.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
|
|
BIT(IEEE80211_STYPE_AUTH >> 4) |
|
|
BIT(IEEE80211_STYPE_DEAUTH >> 4),
|
|
},
|
|
[NL80211_IFTYPE_P2P_DEVICE] = {
|
|
.tx = 0xffff,
|
|
.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
|
|
BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
|
|
},
|
|
};
|
|
|
|
static const struct ieee80211_ht_cap mac80211_ht_capa_mod_mask = {
|
|
.ampdu_params_info = IEEE80211_HT_AMPDU_PARM_FACTOR |
|
|
IEEE80211_HT_AMPDU_PARM_DENSITY,
|
|
|
|
.cap_info = cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
|
|
IEEE80211_HT_CAP_MAX_AMSDU |
|
|
IEEE80211_HT_CAP_SGI_20 |
|
|
IEEE80211_HT_CAP_SGI_40 |
|
|
IEEE80211_HT_CAP_TX_STBC |
|
|
IEEE80211_HT_CAP_RX_STBC |
|
|
IEEE80211_HT_CAP_LDPC_CODING |
|
|
IEEE80211_HT_CAP_40MHZ_INTOLERANT),
|
|
.mcs = {
|
|
.rx_mask = { 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, },
|
|
},
|
|
};
|
|
|
|
static const struct ieee80211_vht_cap mac80211_vht_capa_mod_mask = {
|
|
.vht_cap_info =
|
|
cpu_to_le32(IEEE80211_VHT_CAP_RXLDPC |
|
|
IEEE80211_VHT_CAP_SHORT_GI_80 |
|
|
IEEE80211_VHT_CAP_SHORT_GI_160 |
|
|
IEEE80211_VHT_CAP_RXSTBC_MASK |
|
|
IEEE80211_VHT_CAP_TXSTBC |
|
|
IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
|
|
IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
|
|
IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN |
|
|
IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN |
|
|
IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK),
|
|
.supp_mcs = {
|
|
.rx_mcs_map = cpu_to_le16(~0),
|
|
.tx_mcs_map = cpu_to_le16(~0),
|
|
},
|
|
};
|
|
|
|
struct ieee80211_hw *ieee80211_alloc_hw_nm(size_t priv_data_len,
|
|
const struct ieee80211_ops *ops,
|
|
const char *requested_name)
|
|
{
|
|
struct ieee80211_local *local;
|
|
int priv_size, i;
|
|
struct wiphy *wiphy;
|
|
bool use_chanctx;
|
|
|
|
if (WARN_ON(!ops->tx || !ops->start || !ops->stop || !ops->config ||
|
|
!ops->add_interface || !ops->remove_interface ||
|
|
!ops->configure_filter))
|
|
return NULL;
|
|
|
|
if (WARN_ON(ops->sta_state && (ops->sta_add || ops->sta_remove)))
|
|
return NULL;
|
|
|
|
/* check all or no channel context operations exist */
|
|
i = !!ops->add_chanctx + !!ops->remove_chanctx +
|
|
!!ops->change_chanctx + !!ops->assign_vif_chanctx +
|
|
!!ops->unassign_vif_chanctx;
|
|
if (WARN_ON(i != 0 && i != 5))
|
|
return NULL;
|
|
use_chanctx = i == 5;
|
|
|
|
/* Ensure 32-byte alignment of our private data and hw private data.
|
|
* We use the wiphy priv data for both our ieee80211_local and for
|
|
* the driver's private data
|
|
*
|
|
* In memory it'll be like this:
|
|
*
|
|
* +-------------------------+
|
|
* | struct wiphy |
|
|
* +-------------------------+
|
|
* | struct ieee80211_local |
|
|
* +-------------------------+
|
|
* | driver's private data |
|
|
* +-------------------------+
|
|
*
|
|
*/
|
|
priv_size = ALIGN(sizeof(*local), NETDEV_ALIGN) + priv_data_len;
|
|
|
|
wiphy = wiphy_new_nm(&mac80211_config_ops, priv_size, requested_name);
|
|
|
|
if (!wiphy)
|
|
return NULL;
|
|
|
|
wiphy->mgmt_stypes = ieee80211_default_mgmt_stypes;
|
|
|
|
wiphy->privid = mac80211_wiphy_privid;
|
|
|
|
wiphy->flags |= WIPHY_FLAG_NETNS_OK |
|
|
WIPHY_FLAG_4ADDR_AP |
|
|
WIPHY_FLAG_4ADDR_STATION |
|
|
WIPHY_FLAG_REPORTS_OBSS |
|
|
WIPHY_FLAG_OFFCHAN_TX;
|
|
|
|
if (ops->remain_on_channel)
|
|
wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
|
|
|
|
wiphy->features |= NL80211_FEATURE_SK_TX_STATUS |
|
|
NL80211_FEATURE_SAE |
|
|
NL80211_FEATURE_HT_IBSS |
|
|
NL80211_FEATURE_VIF_TXPOWER |
|
|
NL80211_FEATURE_MAC_ON_CREATE |
|
|
NL80211_FEATURE_USERSPACE_MPM |
|
|
NL80211_FEATURE_FULL_AP_CLIENT_STATE;
|
|
wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_FILS_STA);
|
|
wiphy_ext_feature_set(wiphy,
|
|
NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211);
|
|
|
|
if (!ops->hw_scan) {
|
|
wiphy->features |= NL80211_FEATURE_LOW_PRIORITY_SCAN |
|
|
NL80211_FEATURE_AP_SCAN;
|
|
/*
|
|
* if the driver behaves correctly using the probe request
|
|
* (template) from mac80211, then both of these should be
|
|
* supported even with hw scan - but let drivers opt in.
|
|
*/
|
|
wiphy_ext_feature_set(wiphy,
|
|
NL80211_EXT_FEATURE_SCAN_RANDOM_SN);
|
|
wiphy_ext_feature_set(wiphy,
|
|
NL80211_EXT_FEATURE_SCAN_MIN_PREQ_CONTENT);
|
|
}
|
|
|
|
if (!ops->set_key)
|
|
wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
|
|
|
|
if (ops->wake_tx_queue)
|
|
wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_TXQS);
|
|
|
|
wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_RRM);
|
|
|
|
wiphy->bss_priv_size = sizeof(struct ieee80211_bss);
|
|
|
|
local = wiphy_priv(wiphy);
|
|
|
|
if (sta_info_init(local))
|
|
goto err_free;
|
|
|
|
local->hw.wiphy = wiphy;
|
|
|
|
local->hw.priv = (char *)local + ALIGN(sizeof(*local), NETDEV_ALIGN);
|
|
|
|
local->ops = ops;
|
|
local->use_chanctx = use_chanctx;
|
|
|
|
/*
|
|
* We need a bit of data queued to build aggregates properly, so
|
|
* instruct the TCP stack to allow more than a single ms of data
|
|
* to be queued in the stack. The value is a bit-shift of 1
|
|
* second, so 7 is ~8ms of queued data. Only affects local TCP
|
|
* sockets.
|
|
* This is the default, anyhow - drivers may need to override it
|
|
* for local reasons (longer buffers, longer completion time, or
|
|
* similar).
|
|
*/
|
|
local->hw.tx_sk_pacing_shift = 7;
|
|
|
|
/* set up some defaults */
|
|
local->hw.queues = 1;
|
|
local->hw.max_rates = 1;
|
|
local->hw.max_report_rates = 0;
|
|
local->hw.max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HT;
|
|
local->hw.max_tx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HT;
|
|
local->hw.offchannel_tx_hw_queue = IEEE80211_INVAL_HW_QUEUE;
|
|
local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
|
|
local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
|
|
local->hw.radiotap_mcs_details = IEEE80211_RADIOTAP_MCS_HAVE_MCS |
|
|
IEEE80211_RADIOTAP_MCS_HAVE_GI |
|
|
IEEE80211_RADIOTAP_MCS_HAVE_BW;
|
|
local->hw.radiotap_vht_details = IEEE80211_RADIOTAP_VHT_KNOWN_GI |
|
|
IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH;
|
|
local->hw.uapsd_queues = IEEE80211_DEFAULT_UAPSD_QUEUES;
|
|
local->hw.uapsd_max_sp_len = IEEE80211_DEFAULT_MAX_SP_LEN;
|
|
local->user_power_level = IEEE80211_UNSET_POWER_LEVEL;
|
|
wiphy->ht_capa_mod_mask = &mac80211_ht_capa_mod_mask;
|
|
wiphy->vht_capa_mod_mask = &mac80211_vht_capa_mod_mask;
|
|
|
|
local->ext_capa[7] = WLAN_EXT_CAPA8_OPMODE_NOTIF;
|
|
|
|
wiphy->extended_capabilities = local->ext_capa;
|
|
wiphy->extended_capabilities_mask = local->ext_capa;
|
|
wiphy->extended_capabilities_len =
|
|
ARRAY_SIZE(local->ext_capa);
|
|
|
|
INIT_LIST_HEAD(&local->interfaces);
|
|
INIT_LIST_HEAD(&local->mon_list);
|
|
|
|
__hw_addr_init(&local->mc_list);
|
|
|
|
mutex_init(&local->iflist_mtx);
|
|
mutex_init(&local->mtx);
|
|
|
|
mutex_init(&local->key_mtx);
|
|
spin_lock_init(&local->filter_lock);
|
|
spin_lock_init(&local->rx_path_lock);
|
|
spin_lock_init(&local->queue_stop_reason_lock);
|
|
|
|
for (i = 0; i < IEEE80211_NUM_ACS; i++) {
|
|
INIT_LIST_HEAD(&local->active_txqs[i]);
|
|
spin_lock_init(&local->active_txq_lock[i]);
|
|
}
|
|
local->airtime_flags = AIRTIME_USE_TX | AIRTIME_USE_RX;
|
|
|
|
INIT_LIST_HEAD(&local->chanctx_list);
|
|
mutex_init(&local->chanctx_mtx);
|
|
|
|
INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work);
|
|
|
|
INIT_WORK(&local->restart_work, ieee80211_restart_work);
|
|
|
|
INIT_WORK(&local->radar_detected_work,
|
|
ieee80211_dfs_radar_detected_work);
|
|
|
|
INIT_WORK(&local->reconfig_filter, ieee80211_reconfig_filter);
|
|
local->smps_mode = IEEE80211_SMPS_OFF;
|
|
|
|
INIT_WORK(&local->dynamic_ps_enable_work,
|
|
ieee80211_dynamic_ps_enable_work);
|
|
INIT_WORK(&local->dynamic_ps_disable_work,
|
|
ieee80211_dynamic_ps_disable_work);
|
|
timer_setup(&local->dynamic_ps_timer, ieee80211_dynamic_ps_timer, 0);
|
|
|
|
INIT_WORK(&local->sched_scan_stopped_work,
|
|
ieee80211_sched_scan_stopped_work);
|
|
|
|
INIT_WORK(&local->tdls_chsw_work, ieee80211_tdls_chsw_work);
|
|
|
|
spin_lock_init(&local->ack_status_lock);
|
|
idr_init(&local->ack_status_frames);
|
|
|
|
for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
|
|
skb_queue_head_init(&local->pending[i]);
|
|
atomic_set(&local->agg_queue_stop[i], 0);
|
|
}
|
|
tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending,
|
|
(unsigned long)local);
|
|
|
|
if (ops->wake_tx_queue)
|
|
tasklet_init(&local->wake_txqs_tasklet, ieee80211_wake_txqs,
|
|
(unsigned long)local);
|
|
|
|
tasklet_init(&local->tasklet,
|
|
ieee80211_tasklet_handler,
|
|
(unsigned long) local);
|
|
|
|
skb_queue_head_init(&local->skb_queue);
|
|
skb_queue_head_init(&local->skb_queue_unreliable);
|
|
skb_queue_head_init(&local->skb_queue_tdls_chsw);
|
|
|
|
ieee80211_alloc_led_names(local);
|
|
|
|
ieee80211_roc_setup(local);
|
|
|
|
local->hw.radiotap_timestamp.units_pos = -1;
|
|
local->hw.radiotap_timestamp.accuracy = -1;
|
|
|
|
return &local->hw;
|
|
err_free:
|
|
wiphy_free(wiphy);
|
|
return NULL;
|
|
}
|
|
EXPORT_SYMBOL(ieee80211_alloc_hw_nm);
|
|
|
|
static int ieee80211_init_cipher_suites(struct ieee80211_local *local)
|
|
{
|
|
bool have_wep = !fips_enabled; /* FIPS does not permit the use of RC4 */
|
|
bool have_mfp = ieee80211_hw_check(&local->hw, MFP_CAPABLE);
|
|
int n_suites = 0, r = 0, w = 0;
|
|
u32 *suites;
|
|
static const u32 cipher_suites[] = {
|
|
/* keep WEP first, it may be removed below */
|
|
WLAN_CIPHER_SUITE_WEP40,
|
|
WLAN_CIPHER_SUITE_WEP104,
|
|
WLAN_CIPHER_SUITE_TKIP,
|
|
WLAN_CIPHER_SUITE_CCMP,
|
|
WLAN_CIPHER_SUITE_CCMP_256,
|
|
WLAN_CIPHER_SUITE_GCMP,
|
|
WLAN_CIPHER_SUITE_GCMP_256,
|
|
|
|
/* keep last -- depends on hw flags! */
|
|
WLAN_CIPHER_SUITE_AES_CMAC,
|
|
WLAN_CIPHER_SUITE_BIP_CMAC_256,
|
|
WLAN_CIPHER_SUITE_BIP_GMAC_128,
|
|
WLAN_CIPHER_SUITE_BIP_GMAC_256,
|
|
};
|
|
|
|
if (ieee80211_hw_check(&local->hw, SW_CRYPTO_CONTROL) ||
|
|
local->hw.wiphy->cipher_suites) {
|
|
/* If the driver advertises, or doesn't support SW crypto,
|
|
* we only need to remove WEP if necessary.
|
|
*/
|
|
if (have_wep)
|
|
return 0;
|
|
|
|
/* well if it has _no_ ciphers ... fine */
|
|
if (!local->hw.wiphy->n_cipher_suites)
|
|
return 0;
|
|
|
|
/* Driver provides cipher suites, but we need to exclude WEP */
|
|
suites = kmemdup(local->hw.wiphy->cipher_suites,
|
|
sizeof(u32) * local->hw.wiphy->n_cipher_suites,
|
|
GFP_KERNEL);
|
|
if (!suites)
|
|
return -ENOMEM;
|
|
|
|
for (r = 0; r < local->hw.wiphy->n_cipher_suites; r++) {
|
|
u32 suite = local->hw.wiphy->cipher_suites[r];
|
|
|
|
if (suite == WLAN_CIPHER_SUITE_WEP40 ||
|
|
suite == WLAN_CIPHER_SUITE_WEP104)
|
|
continue;
|
|
suites[w++] = suite;
|
|
}
|
|
} else if (!local->hw.cipher_schemes) {
|
|
/* If the driver doesn't have cipher schemes, there's nothing
|
|
* else to do other than assign the (software supported and
|
|
* perhaps offloaded) cipher suites.
|
|
*/
|
|
local->hw.wiphy->cipher_suites = cipher_suites;
|
|
local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
|
|
|
|
if (!have_mfp)
|
|
local->hw.wiphy->n_cipher_suites -= 4;
|
|
|
|
if (!have_wep) {
|
|
local->hw.wiphy->cipher_suites += 2;
|
|
local->hw.wiphy->n_cipher_suites -= 2;
|
|
}
|
|
|
|
/* not dynamically allocated, so just return */
|
|
return 0;
|
|
} else {
|
|
const struct ieee80211_cipher_scheme *cs;
|
|
|
|
cs = local->hw.cipher_schemes;
|
|
|
|
/* Driver specifies cipher schemes only (but not cipher suites
|
|
* including the schemes)
|
|
*
|
|
* We start counting ciphers defined by schemes, TKIP, CCMP,
|
|
* CCMP-256, GCMP, and GCMP-256
|
|
*/
|
|
n_suites = local->hw.n_cipher_schemes + 5;
|
|
|
|
/* check if we have WEP40 and WEP104 */
|
|
if (have_wep)
|
|
n_suites += 2;
|
|
|
|
/* check if we have AES_CMAC, BIP-CMAC-256, BIP-GMAC-128,
|
|
* BIP-GMAC-256
|
|
*/
|
|
if (have_mfp)
|
|
n_suites += 4;
|
|
|
|
suites = kmalloc_array(n_suites, sizeof(u32), GFP_KERNEL);
|
|
if (!suites)
|
|
return -ENOMEM;
|
|
|
|
suites[w++] = WLAN_CIPHER_SUITE_CCMP;
|
|
suites[w++] = WLAN_CIPHER_SUITE_CCMP_256;
|
|
suites[w++] = WLAN_CIPHER_SUITE_TKIP;
|
|
suites[w++] = WLAN_CIPHER_SUITE_GCMP;
|
|
suites[w++] = WLAN_CIPHER_SUITE_GCMP_256;
|
|
|
|
if (have_wep) {
|
|
suites[w++] = WLAN_CIPHER_SUITE_WEP40;
|
|
suites[w++] = WLAN_CIPHER_SUITE_WEP104;
|
|
}
|
|
|
|
if (have_mfp) {
|
|
suites[w++] = WLAN_CIPHER_SUITE_AES_CMAC;
|
|
suites[w++] = WLAN_CIPHER_SUITE_BIP_CMAC_256;
|
|
suites[w++] = WLAN_CIPHER_SUITE_BIP_GMAC_128;
|
|
suites[w++] = WLAN_CIPHER_SUITE_BIP_GMAC_256;
|
|
}
|
|
|
|
for (r = 0; r < local->hw.n_cipher_schemes; r++) {
|
|
suites[w++] = cs[r].cipher;
|
|
if (WARN_ON(cs[r].pn_len > IEEE80211_MAX_PN_LEN)) {
|
|
kfree(suites);
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
local->hw.wiphy->cipher_suites = suites;
|
|
local->hw.wiphy->n_cipher_suites = w;
|
|
local->wiphy_ciphers_allocated = true;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ieee80211_register_hw(struct ieee80211_hw *hw)
|
|
{
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
int result, i;
|
|
enum nl80211_band band;
|
|
int channels, max_bitrates;
|
|
bool supp_ht, supp_vht, supp_he;
|
|
netdev_features_t feature_whitelist;
|
|
struct cfg80211_chan_def dflt_chandef = {};
|
|
|
|
if (ieee80211_hw_check(hw, QUEUE_CONTROL) &&
|
|
(local->hw.offchannel_tx_hw_queue == IEEE80211_INVAL_HW_QUEUE ||
|
|
local->hw.offchannel_tx_hw_queue >= local->hw.queues))
|
|
return -EINVAL;
|
|
|
|
if ((hw->wiphy->features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH) &&
|
|
(!local->ops->tdls_channel_switch ||
|
|
!local->ops->tdls_cancel_channel_switch ||
|
|
!local->ops->tdls_recv_channel_switch))
|
|
return -EOPNOTSUPP;
|
|
|
|
if (WARN_ON(ieee80211_hw_check(hw, SUPPORTS_TX_FRAG) &&
|
|
!local->ops->set_frag_threshold))
|
|
return -EINVAL;
|
|
|
|
if (WARN_ON(local->hw.wiphy->interface_modes &
|
|
BIT(NL80211_IFTYPE_NAN) &&
|
|
(!local->ops->start_nan || !local->ops->stop_nan)))
|
|
return -EINVAL;
|
|
|
|
#ifdef CONFIG_PM
|
|
if (hw->wiphy->wowlan && (!local->ops->suspend || !local->ops->resume))
|
|
return -EINVAL;
|
|
#endif
|
|
|
|
if (!local->use_chanctx) {
|
|
for (i = 0; i < local->hw.wiphy->n_iface_combinations; i++) {
|
|
const struct ieee80211_iface_combination *comb;
|
|
|
|
comb = &local->hw.wiphy->iface_combinations[i];
|
|
|
|
if (comb->num_different_channels > 1)
|
|
return -EINVAL;
|
|
}
|
|
} else {
|
|
/*
|
|
* WDS is currently prohibited when channel contexts are used
|
|
* because there's no clear definition of which channel WDS
|
|
* type interfaces use
|
|
*/
|
|
if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_WDS))
|
|
return -EINVAL;
|
|
|
|
/* DFS is not supported with multi-channel combinations yet */
|
|
for (i = 0; i < local->hw.wiphy->n_iface_combinations; i++) {
|
|
const struct ieee80211_iface_combination *comb;
|
|
|
|
comb = &local->hw.wiphy->iface_combinations[i];
|
|
|
|
if (comb->radar_detect_widths &&
|
|
comb->num_different_channels > 1)
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
/* Only HW csum features are currently compatible with mac80211 */
|
|
feature_whitelist = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
|
|
NETIF_F_HW_CSUM | NETIF_F_SG | NETIF_F_HIGHDMA |
|
|
NETIF_F_GSO_SOFTWARE | NETIF_F_RXCSUM;
|
|
if (WARN_ON(hw->netdev_features & ~feature_whitelist))
|
|
return -EINVAL;
|
|
|
|
if (hw->max_report_rates == 0)
|
|
hw->max_report_rates = hw->max_rates;
|
|
|
|
local->rx_chains = 1;
|
|
|
|
/*
|
|
* generic code guarantees at least one band,
|
|
* set this very early because much code assumes
|
|
* that hw.conf.channel is assigned
|
|
*/
|
|
channels = 0;
|
|
max_bitrates = 0;
|
|
supp_ht = false;
|
|
supp_vht = false;
|
|
supp_he = false;
|
|
for (band = 0; band < NUM_NL80211_BANDS; band++) {
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
sband = local->hw.wiphy->bands[band];
|
|
if (!sband)
|
|
continue;
|
|
|
|
if (!dflt_chandef.chan) {
|
|
cfg80211_chandef_create(&dflt_chandef,
|
|
&sband->channels[0],
|
|
NL80211_CHAN_NO_HT);
|
|
/* init channel we're on */
|
|
if (!local->use_chanctx && !local->_oper_chandef.chan) {
|
|
local->hw.conf.chandef = dflt_chandef;
|
|
local->_oper_chandef = dflt_chandef;
|
|
}
|
|
local->monitor_chandef = dflt_chandef;
|
|
}
|
|
|
|
channels += sband->n_channels;
|
|
|
|
if (max_bitrates < sband->n_bitrates)
|
|
max_bitrates = sband->n_bitrates;
|
|
supp_ht = supp_ht || sband->ht_cap.ht_supported;
|
|
supp_vht = supp_vht || sband->vht_cap.vht_supported;
|
|
|
|
if (!supp_he)
|
|
supp_he = !!ieee80211_get_he_sta_cap(sband);
|
|
|
|
if (!sband->ht_cap.ht_supported)
|
|
continue;
|
|
|
|
/* TODO: consider VHT for RX chains, hopefully it's the same */
|
|
local->rx_chains =
|
|
max(ieee80211_mcs_to_chains(&sband->ht_cap.mcs),
|
|
local->rx_chains);
|
|
|
|
/* no need to mask, SM_PS_DISABLED has all bits set */
|
|
sband->ht_cap.cap |= WLAN_HT_CAP_SM_PS_DISABLED <<
|
|
IEEE80211_HT_CAP_SM_PS_SHIFT;
|
|
}
|
|
|
|
/* if low-level driver supports AP, we also support VLAN.
|
|
* drivers advertising SW_CRYPTO_CONTROL should enable AP_VLAN
|
|
* based on their support to transmit SW encrypted packets.
|
|
*/
|
|
if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP) &&
|
|
!ieee80211_hw_check(&local->hw, SW_CRYPTO_CONTROL)) {
|
|
hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN);
|
|
hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_AP_VLAN);
|
|
}
|
|
|
|
/* mac80211 always supports monitor */
|
|
hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR);
|
|
hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_MONITOR);
|
|
|
|
/* mac80211 doesn't support more than one IBSS interface right now */
|
|
for (i = 0; i < hw->wiphy->n_iface_combinations; i++) {
|
|
const struct ieee80211_iface_combination *c;
|
|
int j;
|
|
|
|
c = &hw->wiphy->iface_combinations[i];
|
|
|
|
for (j = 0; j < c->n_limits; j++)
|
|
if ((c->limits[j].types & BIT(NL80211_IFTYPE_ADHOC)) &&
|
|
c->limits[j].max > 1)
|
|
return -EINVAL;
|
|
}
|
|
|
|
local->int_scan_req = kzalloc(sizeof(*local->int_scan_req) +
|
|
sizeof(void *) * channels, GFP_KERNEL);
|
|
if (!local->int_scan_req)
|
|
return -ENOMEM;
|
|
|
|
for (band = 0; band < NUM_NL80211_BANDS; band++) {
|
|
if (!local->hw.wiphy->bands[band])
|
|
continue;
|
|
local->int_scan_req->rates[band] = (u32) -1;
|
|
}
|
|
|
|
#ifndef CONFIG_MAC80211_MESH
|
|
/* mesh depends on Kconfig, but drivers should set it if they want */
|
|
local->hw.wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MESH_POINT);
|
|
#endif
|
|
|
|
/* if the underlying driver supports mesh, mac80211 will (at least)
|
|
* provide routing of mesh authentication frames to userspace */
|
|
if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_MESH_POINT))
|
|
local->hw.wiphy->flags |= WIPHY_FLAG_MESH_AUTH;
|
|
|
|
/* mac80211 supports control port protocol changing */
|
|
local->hw.wiphy->flags |= WIPHY_FLAG_CONTROL_PORT_PROTOCOL;
|
|
|
|
if (ieee80211_hw_check(&local->hw, SIGNAL_DBM)) {
|
|
local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
|
|
} else if (ieee80211_hw_check(&local->hw, SIGNAL_UNSPEC)) {
|
|
local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC;
|
|
if (hw->max_signal <= 0) {
|
|
result = -EINVAL;
|
|
goto fail_wiphy_register;
|
|
}
|
|
}
|
|
|
|
/* Enable Extended Key IDs when driver allowed it, or when it
|
|
* supports neither HW crypto nor A-MPDUs
|
|
*/
|
|
if ((!local->ops->set_key &&
|
|
!ieee80211_hw_check(hw, AMPDU_AGGREGATION)) ||
|
|
ieee80211_hw_check(&local->hw, EXT_KEY_ID_NATIVE))
|
|
wiphy_ext_feature_set(local->hw.wiphy,
|
|
NL80211_EXT_FEATURE_EXT_KEY_ID);
|
|
|
|
/* Mac80211 and therefore all cards only using SW crypto are able to
|
|
* handle PTK rekeys correctly
|
|
*/
|
|
if (!local->ops->set_key)
|
|
wiphy_ext_feature_set(local->hw.wiphy,
|
|
NL80211_EXT_FEATURE_CAN_REPLACE_PTK0);
|
|
|
|
/*
|
|
* Calculate scan IE length -- we need this to alloc
|
|
* memory and to subtract from the driver limit. It
|
|
* includes the DS Params, (extended) supported rates, and HT
|
|
* information -- SSID is the driver's responsibility.
|
|
*/
|
|
local->scan_ies_len = 4 + max_bitrates /* (ext) supp rates */ +
|
|
3 /* DS Params */;
|
|
if (supp_ht)
|
|
local->scan_ies_len += 2 + sizeof(struct ieee80211_ht_cap);
|
|
|
|
if (supp_vht)
|
|
local->scan_ies_len +=
|
|
2 + sizeof(struct ieee80211_vht_cap);
|
|
|
|
/* HE cap element is variable in size - set len to allow max size */
|
|
/*
|
|
* TODO: 1 is added at the end of the calculation to accommodate for
|
|
* the temporary placing of the HE capabilities IE under EXT.
|
|
* Remove it once it is placed in the final place.
|
|
*/
|
|
if (supp_he)
|
|
local->scan_ies_len +=
|
|
2 + sizeof(struct ieee80211_he_cap_elem) +
|
|
sizeof(struct ieee80211_he_mcs_nss_supp) +
|
|
IEEE80211_HE_PPE_THRES_MAX_LEN + 1;
|
|
|
|
if (!local->ops->hw_scan) {
|
|
/* For hw_scan, driver needs to set these up. */
|
|
local->hw.wiphy->max_scan_ssids = 4;
|
|
local->hw.wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
|
|
}
|
|
|
|
/*
|
|
* If the driver supports any scan IEs, then assume the
|
|
* limit includes the IEs mac80211 will add, otherwise
|
|
* leave it at zero and let the driver sort it out; we
|
|
* still pass our IEs to the driver but userspace will
|
|
* not be allowed to in that case.
|
|
*/
|
|
if (local->hw.wiphy->max_scan_ie_len)
|
|
local->hw.wiphy->max_scan_ie_len -= local->scan_ies_len;
|
|
|
|
WARN_ON(!ieee80211_cs_list_valid(local->hw.cipher_schemes,
|
|
local->hw.n_cipher_schemes));
|
|
|
|
result = ieee80211_init_cipher_suites(local);
|
|
if (result < 0)
|
|
goto fail_wiphy_register;
|
|
|
|
if (!local->ops->remain_on_channel)
|
|
local->hw.wiphy->max_remain_on_channel_duration = 5000;
|
|
|
|
/* mac80211 based drivers don't support internal TDLS setup */
|
|
if (local->hw.wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS)
|
|
local->hw.wiphy->flags |= WIPHY_FLAG_TDLS_EXTERNAL_SETUP;
|
|
|
|
/* mac80211 supports eCSA, if the driver supports STA CSA at all */
|
|
if (ieee80211_hw_check(&local->hw, CHANCTX_STA_CSA))
|
|
local->ext_capa[0] |= WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING;
|
|
|
|
/* mac80211 supports multi BSSID, if the driver supports it */
|
|
if (ieee80211_hw_check(&local->hw, SUPPORTS_MULTI_BSSID)) {
|
|
local->hw.wiphy->support_mbssid = true;
|
|
if (ieee80211_hw_check(&local->hw,
|
|
SUPPORTS_ONLY_HE_MULTI_BSSID))
|
|
local->hw.wiphy->support_only_he_mbssid = true;
|
|
else
|
|
local->ext_capa[2] |=
|
|
WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT;
|
|
}
|
|
|
|
local->hw.wiphy->max_num_csa_counters = IEEE80211_MAX_CSA_COUNTERS_NUM;
|
|
|
|
result = wiphy_register(local->hw.wiphy);
|
|
if (result < 0)
|
|
goto fail_wiphy_register;
|
|
|
|
/*
|
|
* We use the number of queues for feature tests (QoS, HT) internally
|
|
* so restrict them appropriately.
|
|
*/
|
|
if (hw->queues > IEEE80211_MAX_QUEUES)
|
|
hw->queues = IEEE80211_MAX_QUEUES;
|
|
|
|
local->workqueue =
|
|
alloc_ordered_workqueue("%s", 0, wiphy_name(local->hw.wiphy));
|
|
if (!local->workqueue) {
|
|
result = -ENOMEM;
|
|
goto fail_workqueue;
|
|
}
|
|
|
|
/*
|
|
* The hardware needs headroom for sending the frame,
|
|
* and we need some headroom for passing the frame to monitor
|
|
* interfaces, but never both at the same time.
|
|
*/
|
|
local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom,
|
|
IEEE80211_TX_STATUS_HEADROOM);
|
|
|
|
debugfs_hw_add(local);
|
|
|
|
/*
|
|
* if the driver doesn't specify a max listen interval we
|
|
* use 5 which should be a safe default
|
|
*/
|
|
if (local->hw.max_listen_interval == 0)
|
|
local->hw.max_listen_interval = 5;
|
|
|
|
local->hw.conf.listen_interval = local->hw.max_listen_interval;
|
|
|
|
local->dynamic_ps_forced_timeout = -1;
|
|
|
|
if (!local->hw.max_nan_de_entries)
|
|
local->hw.max_nan_de_entries = IEEE80211_MAX_NAN_INSTANCE_ID;
|
|
|
|
if (!local->hw.weight_multiplier)
|
|
local->hw.weight_multiplier = 1;
|
|
|
|
result = ieee80211_wep_init(local);
|
|
if (result < 0)
|
|
wiphy_debug(local->hw.wiphy, "Failed to initialize wep: %d\n",
|
|
result);
|
|
|
|
local->hw.conf.flags = IEEE80211_CONF_IDLE;
|
|
|
|
ieee80211_led_init(local);
|
|
|
|
result = ieee80211_txq_setup_flows(local);
|
|
if (result)
|
|
goto fail_flows;
|
|
|
|
rtnl_lock();
|
|
|
|
result = ieee80211_init_rate_ctrl_alg(local,
|
|
hw->rate_control_algorithm);
|
|
if (result < 0) {
|
|
wiphy_debug(local->hw.wiphy,
|
|
"Failed to initialize rate control algorithm\n");
|
|
goto fail_rate;
|
|
}
|
|
|
|
if (local->rate_ctrl) {
|
|
clear_bit(IEEE80211_HW_SUPPORTS_VHT_EXT_NSS_BW, hw->flags);
|
|
if (local->rate_ctrl->ops->capa & RATE_CTRL_CAPA_VHT_EXT_NSS_BW)
|
|
ieee80211_hw_set(hw, SUPPORTS_VHT_EXT_NSS_BW);
|
|
}
|
|
|
|
/*
|
|
* If the VHT capabilities don't have IEEE80211_VHT_EXT_NSS_BW_CAPABLE,
|
|
* or have it when we don't, copy the sband structure and set/clear it.
|
|
* This is necessary because rate scaling algorithms could be switched
|
|
* and have different support values.
|
|
* Print a message so that in the common case the reallocation can be
|
|
* avoided.
|
|
*/
|
|
BUILD_BUG_ON(NUM_NL80211_BANDS > 8 * sizeof(local->sband_allocated));
|
|
for (band = 0; band < NUM_NL80211_BANDS; band++) {
|
|
struct ieee80211_supported_band *sband;
|
|
bool local_cap, ie_cap;
|
|
|
|
local_cap = ieee80211_hw_check(hw, SUPPORTS_VHT_EXT_NSS_BW);
|
|
|
|
sband = local->hw.wiphy->bands[band];
|
|
if (!sband || !sband->vht_cap.vht_supported)
|
|
continue;
|
|
|
|
ie_cap = !!(sband->vht_cap.vht_mcs.tx_highest &
|
|
cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE));
|
|
|
|
if (local_cap == ie_cap)
|
|
continue;
|
|
|
|
sband = kmemdup(sband, sizeof(*sband), GFP_KERNEL);
|
|
if (!sband) {
|
|
result = -ENOMEM;
|
|
goto fail_rate;
|
|
}
|
|
|
|
wiphy_dbg(hw->wiphy, "copying sband (band %d) due to VHT EXT NSS BW flag\n",
|
|
band);
|
|
|
|
sband->vht_cap.vht_mcs.tx_highest ^=
|
|
cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE);
|
|
|
|
local->hw.wiphy->bands[band] = sband;
|
|
local->sband_allocated |= BIT(band);
|
|
}
|
|
|
|
/* add one default STA interface if supported */
|
|
if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION) &&
|
|
!ieee80211_hw_check(hw, NO_AUTO_VIF)) {
|
|
struct vif_params params = {0};
|
|
|
|
result = ieee80211_if_add(local, "wlan%d", NET_NAME_ENUM, NULL,
|
|
NL80211_IFTYPE_STATION, ¶ms);
|
|
if (result)
|
|
wiphy_warn(local->hw.wiphy,
|
|
"Failed to add default virtual iface\n");
|
|
}
|
|
|
|
rtnl_unlock();
|
|
|
|
#ifdef CONFIG_INET
|
|
local->ifa_notifier.notifier_call = ieee80211_ifa_changed;
|
|
result = register_inetaddr_notifier(&local->ifa_notifier);
|
|
if (result)
|
|
goto fail_ifa;
|
|
#endif
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
local->ifa6_notifier.notifier_call = ieee80211_ifa6_changed;
|
|
result = register_inet6addr_notifier(&local->ifa6_notifier);
|
|
if (result)
|
|
goto fail_ifa6;
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
fail_ifa6:
|
|
#ifdef CONFIG_INET
|
|
unregister_inetaddr_notifier(&local->ifa_notifier);
|
|
#endif
|
|
#endif
|
|
#if defined(CONFIG_INET) || defined(CONFIG_IPV6)
|
|
fail_ifa:
|
|
#endif
|
|
rtnl_lock();
|
|
rate_control_deinitialize(local);
|
|
ieee80211_remove_interfaces(local);
|
|
fail_rate:
|
|
rtnl_unlock();
|
|
ieee80211_led_exit(local);
|
|
fail_flows:
|
|
destroy_workqueue(local->workqueue);
|
|
fail_workqueue:
|
|
wiphy_unregister(local->hw.wiphy);
|
|
fail_wiphy_register:
|
|
if (local->wiphy_ciphers_allocated)
|
|
kfree(local->hw.wiphy->cipher_suites);
|
|
kfree(local->int_scan_req);
|
|
return result;
|
|
}
|
|
EXPORT_SYMBOL(ieee80211_register_hw);
|
|
|
|
void ieee80211_unregister_hw(struct ieee80211_hw *hw)
|
|
{
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
tasklet_kill(&local->tx_pending_tasklet);
|
|
tasklet_kill(&local->tasklet);
|
|
|
|
#ifdef CONFIG_INET
|
|
unregister_inetaddr_notifier(&local->ifa_notifier);
|
|
#endif
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
unregister_inet6addr_notifier(&local->ifa6_notifier);
|
|
#endif
|
|
|
|
rtnl_lock();
|
|
|
|
/*
|
|
* At this point, interface list manipulations are fine
|
|
* because the driver cannot be handing us frames any
|
|
* more and the tasklet is killed.
|
|
*/
|
|
ieee80211_remove_interfaces(local);
|
|
|
|
rtnl_unlock();
|
|
|
|
cancel_delayed_work_sync(&local->roc_work);
|
|
cancel_work_sync(&local->restart_work);
|
|
cancel_work_sync(&local->reconfig_filter);
|
|
cancel_work_sync(&local->tdls_chsw_work);
|
|
flush_work(&local->sched_scan_stopped_work);
|
|
flush_work(&local->radar_detected_work);
|
|
|
|
ieee80211_clear_tx_pending(local);
|
|
rate_control_deinitialize(local);
|
|
|
|
if (skb_queue_len(&local->skb_queue) ||
|
|
skb_queue_len(&local->skb_queue_unreliable))
|
|
wiphy_warn(local->hw.wiphy, "skb_queue not empty\n");
|
|
skb_queue_purge(&local->skb_queue);
|
|
skb_queue_purge(&local->skb_queue_unreliable);
|
|
skb_queue_purge(&local->skb_queue_tdls_chsw);
|
|
|
|
destroy_workqueue(local->workqueue);
|
|
wiphy_unregister(local->hw.wiphy);
|
|
ieee80211_led_exit(local);
|
|
kfree(local->int_scan_req);
|
|
}
|
|
EXPORT_SYMBOL(ieee80211_unregister_hw);
|
|
|
|
static int ieee80211_free_ack_frame(int id, void *p, void *data)
|
|
{
|
|
WARN_ONCE(1, "Have pending ack frames!\n");
|
|
kfree_skb(p);
|
|
return 0;
|
|
}
|
|
|
|
void ieee80211_free_hw(struct ieee80211_hw *hw)
|
|
{
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
enum nl80211_band band;
|
|
|
|
mutex_destroy(&local->iflist_mtx);
|
|
mutex_destroy(&local->mtx);
|
|
|
|
if (local->wiphy_ciphers_allocated)
|
|
kfree(local->hw.wiphy->cipher_suites);
|
|
|
|
idr_for_each(&local->ack_status_frames,
|
|
ieee80211_free_ack_frame, NULL);
|
|
idr_destroy(&local->ack_status_frames);
|
|
|
|
sta_info_stop(local);
|
|
|
|
ieee80211_free_led_names(local);
|
|
|
|
for (band = 0; band < NUM_NL80211_BANDS; band++) {
|
|
if (!(local->sband_allocated & BIT(band)))
|
|
continue;
|
|
kfree(local->hw.wiphy->bands[band]);
|
|
}
|
|
|
|
wiphy_free(local->hw.wiphy);
|
|
}
|
|
EXPORT_SYMBOL(ieee80211_free_hw);
|
|
|
|
static int __init ieee80211_init(void)
|
|
{
|
|
struct sk_buff *skb;
|
|
int ret;
|
|
|
|
BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb));
|
|
BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) +
|
|
IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb));
|
|
|
|
ret = rc80211_minstrel_init();
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = ieee80211_iface_init();
|
|
if (ret)
|
|
goto err_netdev;
|
|
|
|
return 0;
|
|
err_netdev:
|
|
rc80211_minstrel_exit();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void __exit ieee80211_exit(void)
|
|
{
|
|
rc80211_minstrel_exit();
|
|
|
|
ieee80211s_stop();
|
|
|
|
ieee80211_iface_exit();
|
|
|
|
rcu_barrier();
|
|
}
|
|
|
|
|
|
subsys_initcall(ieee80211_init);
|
|
module_exit(ieee80211_exit);
|
|
|
|
MODULE_DESCRIPTION("IEEE 802.11 subsystem");
|
|
MODULE_LICENSE("GPL");
|