2007-05-06 02:45:53 +08:00
|
|
|
/*
|
|
|
|
* Copyright 2002-2005, Instant802 Networks, Inc.
|
|
|
|
* Copyright 2005-2006, Devicescape Software, Inc.
|
|
|
|
* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
|
2014-09-03 20:24:57 +08:00
|
|
|
* Copyright 2013-2014 Intel Mobile Communications GmbH
|
2018-06-09 14:14:44 +08:00
|
|
|
* Copyright (C) 2017 Intel Deutschland GmbH
|
2018-08-31 16:31:17 +08:00
|
|
|
* Copyright (C) 2018 Intel Corporation
|
2007-05-06 02:45:53 +08:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <net/mac80211.h>
|
|
|
|
#include <linux/module.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>
|
2010-06-09 18:43:26 +08:00
|
|
|
#include <linux/inetdevice.h>
|
2007-09-18 02:56:21 +08:00
|
|
|
#include <net/net_namespace.h>
|
2007-05-06 02:45:53 +08:00
|
|
|
#include <net/cfg80211.h>
|
2013-01-14 22:14:34 +08:00
|
|
|
#include <net/addrconf.h>
|
2007-05-06 02:45:53 +08:00
|
|
|
|
|
|
|
#include "ieee80211_i.h"
|
2009-04-24 00:52:52 +08:00
|
|
|
#include "driver-ops.h"
|
2008-04-09 03:14:40 +08:00
|
|
|
#include "rate.h"
|
2008-02-23 22:17:18 +08:00
|
|
|
#include "mesh.h"
|
2007-05-06 02:45:53 +08:00
|
|
|
#include "wep.h"
|
2008-04-09 03:14:40 +08:00
|
|
|
#include "led.h"
|
2007-05-06 02:46:38 +08:00
|
|
|
#include "debugfs.h"
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2008-09-11 06:01:59 +08:00
|
|
|
void ieee80211_configure_filter(struct ieee80211_local *local)
|
[PATCH] mac80211: revamp interface and filter configuration
Drivers are currently supposed to keep track of monitor
interfaces if they allow so-called "hard" monitor, and
they are also supposed to keep track of multicast etc.
This patch changes that, replaces the set_multicast_list()
callback with a new configure_filter() callback that takes
filter flags (FIF_*) instead of interface flags (IFF_*).
For a driver, this means it should open the filter as much
as necessary to get all frames requested by the filter flags.
Accordingly, the filter flags are named "positively", e.g.
FIF_ALLMULTI.
Multicast filtering is a bit special in that drivers that
have no multicast address filters need to allow multicast
frames through when either the FIF_ALLMULTI flag is set or
when the mc_count value is positive.
At the same time, drivers are no longer notified about
monitor interfaces at all, this means they now need to
implement the start() and stop() callbacks and the new
change_filter_flags() callback. Also, the start()/stop()
ordering changed, start() is now called *before* any
add_interface() as it really should be, and stop() after
any remove_interface().
The patch also changes the behaviour of setting the bssid
to multicast for scanning when IEEE80211_HW_NO_PROBE_FILTERING
is set; the IEEE80211_HW_NO_PROBE_FILTERING flag is removed
and the filter flag FIF_BCN_PRBRESP_PROMISC introduced.
This is a lot more efficient for hardware like b43 that
supports it and other hardware can still set the BSSID
to all-ones.
Driver modifications by Johannes Berg (b43 & iwlwifi), Michael Wu
(rtl8187, adm8211, and p54), Larry Finger (b43legacy), and
Ivo van Doorn (rt2x00).
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2007-09-17 13:29:23 +08:00
|
|
|
{
|
2009-08-17 22:16:53 +08:00
|
|
|
u64 mc;
|
[PATCH] mac80211: revamp interface and filter configuration
Drivers are currently supposed to keep track of monitor
interfaces if they allow so-called "hard" monitor, and
they are also supposed to keep track of multicast etc.
This patch changes that, replaces the set_multicast_list()
callback with a new configure_filter() callback that takes
filter flags (FIF_*) instead of interface flags (IFF_*).
For a driver, this means it should open the filter as much
as necessary to get all frames requested by the filter flags.
Accordingly, the filter flags are named "positively", e.g.
FIF_ALLMULTI.
Multicast filtering is a bit special in that drivers that
have no multicast address filters need to allow multicast
frames through when either the FIF_ALLMULTI flag is set or
when the mc_count value is positive.
At the same time, drivers are no longer notified about
monitor interfaces at all, this means they now need to
implement the start() and stop() callbacks and the new
change_filter_flags() callback. Also, the start()/stop()
ordering changed, start() is now called *before* any
add_interface() as it really should be, and stop() after
any remove_interface().
The patch also changes the behaviour of setting the bssid
to multicast for scanning when IEEE80211_HW_NO_PROBE_FILTERING
is set; the IEEE80211_HW_NO_PROBE_FILTERING flag is removed
and the filter flag FIF_BCN_PRBRESP_PROMISC introduced.
This is a lot more efficient for hardware like b43 that
supports it and other hardware can still set the BSSID
to all-ones.
Driver modifications by Johannes Berg (b43 & iwlwifi), Michael Wu
(rtl8187, adm8211, and p54), Larry Finger (b43legacy), and
Ivo van Doorn (rt2x00).
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2007-09-17 13:29:23 +08:00
|
|
|
unsigned int changed_flags;
|
|
|
|
unsigned int new_flags = 0;
|
|
|
|
|
2007-09-26 21:19:47 +08:00
|
|
|
if (atomic_read(&local->iff_allmultis))
|
[PATCH] mac80211: revamp interface and filter configuration
Drivers are currently supposed to keep track of monitor
interfaces if they allow so-called "hard" monitor, and
they are also supposed to keep track of multicast etc.
This patch changes that, replaces the set_multicast_list()
callback with a new configure_filter() callback that takes
filter flags (FIF_*) instead of interface flags (IFF_*).
For a driver, this means it should open the filter as much
as necessary to get all frames requested by the filter flags.
Accordingly, the filter flags are named "positively", e.g.
FIF_ALLMULTI.
Multicast filtering is a bit special in that drivers that
have no multicast address filters need to allow multicast
frames through when either the FIF_ALLMULTI flag is set or
when the mc_count value is positive.
At the same time, drivers are no longer notified about
monitor interfaces at all, this means they now need to
implement the start() and stop() callbacks and the new
change_filter_flags() callback. Also, the start()/stop()
ordering changed, start() is now called *before* any
add_interface() as it really should be, and stop() after
any remove_interface().
The patch also changes the behaviour of setting the bssid
to multicast for scanning when IEEE80211_HW_NO_PROBE_FILTERING
is set; the IEEE80211_HW_NO_PROBE_FILTERING flag is removed
and the filter flag FIF_BCN_PRBRESP_PROMISC introduced.
This is a lot more efficient for hardware like b43 that
supports it and other hardware can still set the BSSID
to all-ones.
Driver modifications by Johannes Berg (b43 & iwlwifi), Michael Wu
(rtl8187, adm8211, and p54), Larry Finger (b43legacy), and
Ivo van Doorn (rt2x00).
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2007-09-17 13:29:23 +08:00
|
|
|
new_flags |= FIF_ALLMULTI;
|
|
|
|
|
2012-04-18 01:54:16 +08:00
|
|
|
if (local->monitors || test_bit(SCAN_SW_SCANNING, &local->scanning) ||
|
|
|
|
test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning))
|
2008-02-01 02:48:23 +08:00
|
|
|
new_flags |= FIF_BCN_PRBRESP_PROMISC;
|
|
|
|
|
2010-10-13 18:06:24 +08:00
|
|
|
if (local->fif_probe_req || local->probe_req_reg)
|
|
|
|
new_flags |= FIF_PROBE_REQ;
|
|
|
|
|
2008-02-01 02:48:23 +08:00
|
|
|
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;
|
[PATCH] mac80211: revamp interface and filter configuration
Drivers are currently supposed to keep track of monitor
interfaces if they allow so-called "hard" monitor, and
they are also supposed to keep track of multicast etc.
This patch changes that, replaces the set_multicast_list()
callback with a new configure_filter() callback that takes
filter flags (FIF_*) instead of interface flags (IFF_*).
For a driver, this means it should open the filter as much
as necessary to get all frames requested by the filter flags.
Accordingly, the filter flags are named "positively", e.g.
FIF_ALLMULTI.
Multicast filtering is a bit special in that drivers that
have no multicast address filters need to allow multicast
frames through when either the FIF_ALLMULTI flag is set or
when the mc_count value is positive.
At the same time, drivers are no longer notified about
monitor interfaces at all, this means they now need to
implement the start() and stop() callbacks and the new
change_filter_flags() callback. Also, the start()/stop()
ordering changed, start() is now called *before* any
add_interface() as it really should be, and stop() after
any remove_interface().
The patch also changes the behaviour of setting the bssid
to multicast for scanning when IEEE80211_HW_NO_PROBE_FILTERING
is set; the IEEE80211_HW_NO_PROBE_FILTERING flag is removed
and the filter flag FIF_BCN_PRBRESP_PROMISC introduced.
This is a lot more efficient for hardware like b43 that
supports it and other hardware can still set the BSSID
to all-ones.
Driver modifications by Johannes Berg (b43 & iwlwifi), Michael Wu
(rtl8187, adm8211, and p54), Larry Finger (b43legacy), and
Ivo van Doorn (rt2x00).
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2007-09-17 13:29:23 +08:00
|
|
|
|
2009-08-04 20:48:51 +08:00
|
|
|
if (local->fif_pspoll)
|
|
|
|
new_flags |= FIF_PSPOLL;
|
|
|
|
|
2009-08-17 22:16:53 +08:00
|
|
|
spin_lock_bh(&local->filter_lock);
|
[PATCH] mac80211: revamp interface and filter configuration
Drivers are currently supposed to keep track of monitor
interfaces if they allow so-called "hard" monitor, and
they are also supposed to keep track of multicast etc.
This patch changes that, replaces the set_multicast_list()
callback with a new configure_filter() callback that takes
filter flags (FIF_*) instead of interface flags (IFF_*).
For a driver, this means it should open the filter as much
as necessary to get all frames requested by the filter flags.
Accordingly, the filter flags are named "positively", e.g.
FIF_ALLMULTI.
Multicast filtering is a bit special in that drivers that
have no multicast address filters need to allow multicast
frames through when either the FIF_ALLMULTI flag is set or
when the mc_count value is positive.
At the same time, drivers are no longer notified about
monitor interfaces at all, this means they now need to
implement the start() and stop() callbacks and the new
change_filter_flags() callback. Also, the start()/stop()
ordering changed, start() is now called *before* any
add_interface() as it really should be, and stop() after
any remove_interface().
The patch also changes the behaviour of setting the bssid
to multicast for scanning when IEEE80211_HW_NO_PROBE_FILTERING
is set; the IEEE80211_HW_NO_PROBE_FILTERING flag is removed
and the filter flag FIF_BCN_PRBRESP_PROMISC introduced.
This is a lot more efficient for hardware like b43 that
supports it and other hardware can still set the BSSID
to all-ones.
Driver modifications by Johannes Berg (b43 & iwlwifi), Michael Wu
(rtl8187, adm8211, and p54), Larry Finger (b43legacy), and
Ivo van Doorn (rt2x00).
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2007-09-17 13:29:23 +08:00
|
|
|
changed_flags = local->filter_flags ^ new_flags;
|
|
|
|
|
2010-04-02 05:22:57 +08:00
|
|
|
mc = drv_prepare_multicast(local, &local->mc_list);
|
2009-08-17 22:16:53 +08:00
|
|
|
spin_unlock_bh(&local->filter_lock);
|
|
|
|
|
[PATCH] mac80211: revamp interface and filter configuration
Drivers are currently supposed to keep track of monitor
interfaces if they allow so-called "hard" monitor, and
they are also supposed to keep track of multicast etc.
This patch changes that, replaces the set_multicast_list()
callback with a new configure_filter() callback that takes
filter flags (FIF_*) instead of interface flags (IFF_*).
For a driver, this means it should open the filter as much
as necessary to get all frames requested by the filter flags.
Accordingly, the filter flags are named "positively", e.g.
FIF_ALLMULTI.
Multicast filtering is a bit special in that drivers that
have no multicast address filters need to allow multicast
frames through when either the FIF_ALLMULTI flag is set or
when the mc_count value is positive.
At the same time, drivers are no longer notified about
monitor interfaces at all, this means they now need to
implement the start() and stop() callbacks and the new
change_filter_flags() callback. Also, the start()/stop()
ordering changed, start() is now called *before* any
add_interface() as it really should be, and stop() after
any remove_interface().
The patch also changes the behaviour of setting the bssid
to multicast for scanning when IEEE80211_HW_NO_PROBE_FILTERING
is set; the IEEE80211_HW_NO_PROBE_FILTERING flag is removed
and the filter flag FIF_BCN_PRBRESP_PROMISC introduced.
This is a lot more efficient for hardware like b43 that
supports it and other hardware can still set the BSSID
to all-ones.
Driver modifications by Johannes Berg (b43 & iwlwifi), Michael Wu
(rtl8187, adm8211, and p54), Larry Finger (b43legacy), and
Ivo van Doorn (rt2x00).
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2007-09-17 13:29:23 +08:00
|
|
|
/* be a bit nasty */
|
|
|
|
new_flags |= (1<<31);
|
|
|
|
|
2009-08-17 22:16:53 +08:00
|
|
|
drv_configure_filter(local, changed_flags, &new_flags, mc);
|
[PATCH] mac80211: revamp interface and filter configuration
Drivers are currently supposed to keep track of monitor
interfaces if they allow so-called "hard" monitor, and
they are also supposed to keep track of multicast etc.
This patch changes that, replaces the set_multicast_list()
callback with a new configure_filter() callback that takes
filter flags (FIF_*) instead of interface flags (IFF_*).
For a driver, this means it should open the filter as much
as necessary to get all frames requested by the filter flags.
Accordingly, the filter flags are named "positively", e.g.
FIF_ALLMULTI.
Multicast filtering is a bit special in that drivers that
have no multicast address filters need to allow multicast
frames through when either the FIF_ALLMULTI flag is set or
when the mc_count value is positive.
At the same time, drivers are no longer notified about
monitor interfaces at all, this means they now need to
implement the start() and stop() callbacks and the new
change_filter_flags() callback. Also, the start()/stop()
ordering changed, start() is now called *before* any
add_interface() as it really should be, and stop() after
any remove_interface().
The patch also changes the behaviour of setting the bssid
to multicast for scanning when IEEE80211_HW_NO_PROBE_FILTERING
is set; the IEEE80211_HW_NO_PROBE_FILTERING flag is removed
and the filter flag FIF_BCN_PRBRESP_PROMISC introduced.
This is a lot more efficient for hardware like b43 that
supports it and other hardware can still set the BSSID
to all-ones.
Driver modifications by Johannes Berg (b43 & iwlwifi), Michael Wu
(rtl8187, adm8211, and p54), Larry Finger (b43legacy), and
Ivo van Doorn (rt2x00).
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2007-09-17 13:29:23 +08:00
|
|
|
|
|
|
|
WARN_ON(new_flags & (1<<31));
|
|
|
|
|
|
|
|
local->filter_flags = new_flags & ~(1<<31);
|
|
|
|
}
|
|
|
|
|
2009-08-17 22:16:53 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2012-07-26 23:24:39 +08:00
|
|
|
static u32 ieee80211_hw_conf_chan(struct ieee80211_local *local)
|
2007-07-27 21:43:23 +08:00
|
|
|
{
|
2012-10-24 16:59:25 +08:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2013-03-25 23:26:57 +08:00
|
|
|
struct cfg80211_chan_def chandef = {};
|
2012-07-26 23:24:39 +08:00
|
|
|
u32 changed = 0;
|
2008-10-09 18:18:51 +08:00
|
|
|
int power;
|
2010-07-29 23:36:43 +08:00
|
|
|
u32 offchannel_flag;
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2010-07-29 23:36:43 +08:00
|
|
|
offchannel_flag = local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL;
|
2013-03-25 23:26:57 +08:00
|
|
|
|
2013-07-08 22:55:56 +08:00
|
|
|
if (local->scan_chandef.chan) {
|
|
|
|
chandef = local->scan_chandef;
|
mac80211: Optimize scans on current operating channel.
This should decrease un-necessary flushes, on/off channel work,
and channel changes in cases where the only scanned channel is
the current operating channel.
* Removes SCAN_OFF_CHANNEL flag, uses SDATA_STATE_OFFCHANNEL
and is-scanning flags instead.
* Add helper method to determine if we are currently configured
for the operating channel.
* Do no blindly go off/on channel in work.c Instead, only call
appropriate on/off code when we really need to change channels.
Always enable offchannel-ps mode when starting work,
and disable it when we are done.
* Consolidate ieee80211_offchannel_stop_station and
ieee80211_offchannel_stop_beaconing, call it
ieee80211_offchannel_stop_vifs instead.
* Accept non-beacon frames when scanning on operating channel.
* Scan state machine optimized to minimize on/off channel
transitions. Also, when going on-channel, go ahead and
re-enable beaconing. We're going to be there for 200ms,
so seems like some useful beaconing could happen.
Always enable offchannel-ps mode when starting software
scan, and disable it when we are done.
* Grab local->mtx earlier in __ieee80211_scan_completed_finish
so that we are protected when calling hw_config(), etc.
* Pass probe-responses up the stack if scanning on local
channel, so that mlme can take a look.
Signed-off-by: Ben Greear <greearb@candelatech.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2011-02-05 03:54:17 +08:00
|
|
|
} else if (local->tmp_channel) {
|
2013-03-25 23:26:57 +08:00
|
|
|
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))
|
mac80211: Optimize scans on current operating channel.
This should decrease un-necessary flushes, on/off channel work,
and channel changes in cases where the only scanned channel is
the current operating channel.
* Removes SCAN_OFF_CHANNEL flag, uses SDATA_STATE_OFFCHANNEL
and is-scanning flags instead.
* Add helper method to determine if we are currently configured
for the operating channel.
* Do no blindly go off/on channel in work.c Instead, only call
appropriate on/off code when we really need to change channels.
Always enable offchannel-ps mode when starting work,
and disable it when we are done.
* Consolidate ieee80211_offchannel_stop_station and
ieee80211_offchannel_stop_beaconing, call it
ieee80211_offchannel_stop_vifs instead.
* Accept non-beacon frames when scanning on operating channel.
* Scan state machine optimized to minimize on/off channel
transitions. Also, when going on-channel, go ahead and
re-enable beaconing. We're going to be there for 200ms,
so seems like some useful beaconing could happen.
Always enable offchannel-ps mode when starting software
scan, and disable it when we are done.
* Grab local->mtx earlier in __ieee80211_scan_completed_finish
so that we are protected when calling hw_config(), etc.
* Pass probe-responses up the stack if scanning on local
channel, so that mlme can take a look.
Signed-off-by: Ben Greear <greearb@candelatech.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2011-02-05 03:54:17 +08:00
|
|
|
local->hw.conf.flags |= IEEE80211_CONF_OFFCHANNEL;
|
|
|
|
else
|
|
|
|
local->hw.conf.flags &= ~IEEE80211_CONF_OFFCHANNEL;
|
|
|
|
|
2010-07-29 23:36:43 +08:00
|
|
|
offchannel_flag ^= local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL;
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2013-03-25 23:26:57 +08:00
|
|
|
if (offchannel_flag ||
|
|
|
|
!cfg80211_chandef_identical(&local->hw.conf.chandef,
|
|
|
|
&local->_oper_chandef)) {
|
|
|
|
local->hw.conf.chandef = chandef;
|
2008-10-09 18:18:51 +08:00
|
|
|
changed |= IEEE80211_CONF_CHANGE_CHANNEL;
|
|
|
|
}
|
2008-01-25 02:38:38 +08:00
|
|
|
|
2009-12-01 20:37:02 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-07-08 22:55:55 +08:00
|
|
|
power = ieee80211_chandef_max_power(&chandef);
|
2009-01-09 20:44:15 +08:00
|
|
|
|
2012-10-24 16:59:25 +08:00
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
|
|
|
if (!rcu_access_pointer(sdata->vif.chanctx_conf))
|
|
|
|
continue;
|
2014-04-10 21:06:48 +08:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
|
|
|
|
continue;
|
2012-10-24 16:59:25 +08:00
|
|
|
power = min(power, sdata->vif.bss_conf.txpower);
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
2009-01-09 20:44:15 +08:00
|
|
|
|
2008-10-09 18:18:51 +08:00
|
|
|
if (local->hw.conf.power_level != power) {
|
|
|
|
changed |= IEEE80211_CONF_CHANGE_POWER;
|
|
|
|
local->hw.conf.power_level = power;
|
|
|
|
}
|
2007-07-27 21:43:23 +08:00
|
|
|
|
2012-07-26 23:24:39 +08:00
|
|
|
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);
|
|
|
|
|
2008-10-09 18:18:51 +08:00
|
|
|
if (changed && local->open_count) {
|
2009-04-24 00:52:52 +08:00
|
|
|
ret = drv_config(local, changed);
|
2008-10-07 18:04:34 +08:00
|
|
|
/*
|
2008-12-05 06:49:08 +08:00
|
|
|
* Goal:
|
2008-10-07 18:04:34 +08:00
|
|
|
* HW reconfiguration should never fail, the driver has told
|
|
|
|
* us what it can support so it should live up to that promise.
|
2008-12-05 06:49:08 +08:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*
|
2008-10-07 18:04:34 +08:00
|
|
|
*/
|
2008-12-05 06:49:08 +08:00
|
|
|
/* WARN_ON(ret); */
|
2008-10-07 18:04:34 +08:00
|
|
|
}
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2007-07-27 21:43:23 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2007-12-28 21:32:58 +08:00
|
|
|
void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
|
|
|
|
u32 changed)
|
2007-07-27 21:43:24 +08:00
|
|
|
{
|
2007-12-28 21:32:58 +08:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
|
2014-04-09 06:08:01 +08:00
|
|
|
if (!changed || sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
|
2007-12-28 21:32:58 +08:00
|
|
|
return;
|
|
|
|
|
2009-11-26 03:30:31 +08:00
|
|
|
drv_bss_info_changed(local, sdata, &sdata->vif.bss_conf, changed);
|
2007-07-27 21:43:24 +08:00
|
|
|
}
|
|
|
|
|
2008-08-03 08:04:37 +08:00
|
|
|
u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
|
2007-07-27 21:43:24 +08:00
|
|
|
{
|
2008-10-11 07:51:51 +08:00
|
|
|
sdata->vif.bss_conf.use_cts_prot = false;
|
|
|
|
sdata->vif.bss_conf.use_short_preamble = false;
|
|
|
|
sdata->vif.bss_conf.use_short_slot = false;
|
2008-10-08 16:59:33 +08:00
|
|
|
return BSS_CHANGED_ERP_CTS_PROT |
|
|
|
|
BSS_CHANGED_ERP_PREAMBLE |
|
|
|
|
BSS_CHANGED_ERP_SLOT;
|
2007-07-27 21:43:24 +08:00
|
|
|
}
|
|
|
|
|
2007-05-06 02:45:53 +08:00
|
|
|
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:
|
2007-12-19 08:31:27 +08:00
|
|
|
/* Clear skb->pkt_type in order to not confuse kernel
|
2007-05-06 02:45:53 +08:00
|
|
|
* netstack. */
|
|
|
|
skb->pkt_type = 0;
|
2012-02-26 18:24:35 +08:00
|
|
|
ieee80211_rx(&local->hw, skb);
|
2007-05-06 02:45:53 +08:00
|
|
|
break;
|
|
|
|
case IEEE80211_TX_STATUS_MSG:
|
|
|
|
skb->pkt_type = 0;
|
2012-02-26 18:24:35 +08:00
|
|
|
ieee80211_tx_status(&local->hw, skb);
|
2007-05-06 02:45:53 +08:00
|
|
|
break;
|
2008-06-30 21:10:46 +08:00
|
|
|
default:
|
2008-12-18 04:26:59 +08:00
|
|
|
WARN(1, "mac80211: Packet is of unknown type %d\n",
|
|
|
|
skb->pkt_type);
|
2007-05-06 02:45:53 +08:00
|
|
|
dev_kfree_skb(skb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-14 16:09:24 +08:00
|
|
|
static void ieee80211_restart_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local =
|
|
|
|
container_of(work, struct ieee80211_local, restart_work);
|
2015-05-22 16:22:40 +08:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2009-04-14 16:09:24 +08:00
|
|
|
|
2010-10-01 20:05:27 +08:00
|
|
|
/* wait for scan work complete */
|
|
|
|
flush_workqueue(local->workqueue);
|
2016-01-05 22:28:06 +08:00
|
|
|
flush_work(&local->sched_scan_stopped_work);
|
2010-10-01 20:05:27 +08:00
|
|
|
|
2013-12-09 03:48:57 +08:00
|
|
|
WARN(test_bit(SCAN_HW_SCANNING, &local->scanning),
|
|
|
|
"%s called with hardware scan in progress\n", __func__);
|
2010-10-01 20:05:27 +08:00
|
|
|
|
2017-04-26 15:58:53 +08:00
|
|
|
flush_work(&local->radar_detected_work);
|
2009-04-14 16:09:24 +08:00
|
|
|
rtnl_lock();
|
2018-08-31 16:31:06 +08:00
|
|
|
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);
|
|
|
|
}
|
2015-05-22 16:22:40 +08:00
|
|
|
flush_delayed_work(&sdata->dec_tailroom_needed_wk);
|
2018-08-31 16:31:06 +08:00
|
|
|
}
|
2010-10-06 17:22:10 +08:00
|
|
|
ieee80211_scan_cancel(local);
|
2015-12-14 22:26:57 +08:00
|
|
|
|
|
|
|
/* make sure any new ROC will consider local->in_reconfig */
|
|
|
|
flush_delayed_work(&local->roc_work);
|
|
|
|
flush_work(&local->hw_roc_done);
|
|
|
|
|
2017-10-29 17:51:08 +08:00
|
|
|
/* wait for all packet processing to be done */
|
|
|
|
synchronize_net();
|
|
|
|
|
2009-04-14 16:09:24 +08:00
|
|
|
ieee80211_reconfig(local);
|
|
|
|
rtnl_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_restart_hw(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
2010-04-07 22:48:40 +08:00
|
|
|
trace_api_restart_hw(local);
|
|
|
|
|
2011-03-07 20:09:12 +08:00
|
|
|
wiphy_info(hw->wiphy,
|
|
|
|
"Hardware restart was requested\n");
|
|
|
|
|
2010-08-31 03:12:02 +08:00
|
|
|
/* use this reason, ieee80211_reconfig will unblock it */
|
2013-02-13 19:25:28 +08:00
|
|
|
ieee80211_stop_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
|
2014-06-13 21:30:05 +08:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_SUSPEND,
|
|
|
|
false);
|
2009-04-14 16:09:24 +08:00
|
|
|
|
2012-06-06 16:25:02 +08:00
|
|
|
/*
|
|
|
|
* 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();
|
|
|
|
|
2015-10-25 16:59:35 +08:00
|
|
|
queue_work(system_freezable_wq, &local->restart_work);
|
2009-04-14 16:09:24 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_restart_hw);
|
|
|
|
|
2010-06-05 02:25:44 +08:00
|
|
|
#ifdef CONFIG_INET
|
2010-05-27 20:32:13 +08:00
|
|
|
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;
|
2010-06-09 18:43:26 +08:00
|
|
|
struct in_device *idev;
|
2010-05-27 20:32:13 +08:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2010-06-09 18:43:26 +08:00
|
|
|
struct ieee80211_bss_conf *bss_conf;
|
2010-05-27 20:32:13 +08:00
|
|
|
struct ieee80211_if_managed *ifmgd;
|
2010-06-09 18:43:26 +08:00
|
|
|
int c = 0;
|
2010-05-27 20:32:13 +08:00
|
|
|
|
|
|
|
/* 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);
|
2010-06-09 18:43:26 +08:00
|
|
|
bss_conf = &sdata->vif.bss_conf;
|
2010-05-27 20:32:13 +08:00
|
|
|
|
|
|
|
/* ARP filtering is only supported in managed mode */
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION)
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
2010-09-15 12:04:31 +08:00
|
|
|
idev = __in_dev_get_rtnl(sdata->dev);
|
2010-06-09 18:43:26 +08:00
|
|
|
if (!idev)
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
2010-05-27 20:32:13 +08:00
|
|
|
ifmgd = &sdata->u.mgd;
|
2013-05-10 18:32:47 +08:00
|
|
|
sdata_lock(sdata);
|
2010-06-09 18:43:26 +08:00
|
|
|
|
|
|
|
/* Copy the addresses to the bss_conf list */
|
|
|
|
ifa = idev->ifa_list;
|
2013-01-14 23:39:07 +08:00
|
|
|
while (ifa) {
|
|
|
|
if (c < IEEE80211_BSS_ARP_ADDR_LIST_LEN)
|
|
|
|
bss_conf->arp_addr_list[c] = ifa->ifa_address;
|
2010-06-09 18:43:26 +08:00
|
|
|
ifa = ifa->ifa_next;
|
|
|
|
c++;
|
|
|
|
}
|
|
|
|
|
|
|
|
bss_conf->arp_addr_cnt = c;
|
|
|
|
|
2011-12-12 21:30:04 +08:00
|
|
|
/* Configure driver only if associated (which also implies it is up) */
|
2013-01-14 23:39:07 +08:00
|
|
|
if (ifmgd->associated)
|
2010-06-09 18:43:26 +08:00
|
|
|
ieee80211_bss_info_change_notify(sdata,
|
|
|
|
BSS_CHANGED_ARP_FILTER);
|
|
|
|
|
2013-05-10 18:32:47 +08:00
|
|
|
sdata_unlock(sdata);
|
2010-05-27 20:32:13 +08:00
|
|
|
|
2014-04-21 12:53:05 +08:00
|
|
|
return NOTIFY_OK;
|
2010-05-27 20:32:13 +08:00
|
|
|
}
|
2010-06-05 02:25:44 +08:00
|
|
|
#endif
|
2010-05-27 20:32:13 +08:00
|
|
|
|
2013-01-14 22:14:34 +08:00
|
|
|
#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);
|
|
|
|
|
2014-04-21 12:53:05 +08:00
|
|
|
return NOTIFY_OK;
|
2013-01-14 22:14:34 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-08-12 21:38:38 +08:00
|
|
|
/* 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,
|
2012-06-20 05:59:14 +08:00
|
|
|
.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
|
|
|
|
BIT(IEEE80211_STYPE_AUTH >> 4) |
|
2012-11-30 07:18:12 +08:00
|
|
|
BIT(IEEE80211_STYPE_DEAUTH >> 4) |
|
|
|
|
BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
|
2010-08-12 21:38:38 +08:00
|
|
|
},
|
|
|
|
[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) |
|
2010-09-16 20:58:23 +08:00
|
|
|
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) |
|
2010-08-12 21:38:38 +08:00
|
|
|
BIT(IEEE80211_STYPE_DISASSOC >> 4) |
|
|
|
|
BIT(IEEE80211_STYPE_AUTH >> 4) |
|
|
|
|
BIT(IEEE80211_STYPE_DEAUTH >> 4) |
|
|
|
|
BIT(IEEE80211_STYPE_ACTION >> 4),
|
|
|
|
},
|
2010-12-17 09:37:50 +08:00
|
|
|
[NL80211_IFTYPE_MESH_POINT] = {
|
|
|
|
.tx = 0xffff,
|
2011-04-08 06:08:31 +08:00
|
|
|
.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
|
|
|
|
BIT(IEEE80211_STYPE_AUTH >> 4) |
|
|
|
|
BIT(IEEE80211_STYPE_DEAUTH >> 4),
|
2010-12-17 09:37:50 +08:00
|
|
|
},
|
2012-06-19 02:07:15 +08:00
|
|
|
[NL80211_IFTYPE_P2P_DEVICE] = {
|
|
|
|
.tx = 0xffff,
|
|
|
|
.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
|
|
|
|
BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
|
|
|
|
},
|
2010-08-12 21:38:38 +08:00
|
|
|
};
|
|
|
|
|
2011-11-19 03:32:00 +08:00
|
|
|
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 |
|
2012-12-13 08:56:20 +08:00
|
|
|
IEEE80211_HT_CAP_SGI_20 |
|
2014-04-01 13:13:21 +08:00
|
|
|
IEEE80211_HT_CAP_SGI_40 |
|
2014-04-16 00:13:56 +08:00
|
|
|
IEEE80211_HT_CAP_LDPC_CODING |
|
|
|
|
IEEE80211_HT_CAP_40MHZ_INTOLERANT),
|
2011-11-19 03:32:00 +08:00
|
|
|
.mcs = {
|
|
|
|
.rx_mask = { 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, },
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2013-02-22 00:40:19 +08:00
|
|
|
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 |
|
2018-08-23 07:01:04 +08:00
|
|
|
IEEE80211_VHT_CAP_RXSTBC_MASK |
|
2013-02-22 00:40:19 +08:00
|
|
|
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),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2014-10-23 03:23:01 +08:00
|
|
|
struct ieee80211_hw *ieee80211_alloc_hw_nm(size_t priv_data_len,
|
|
|
|
const struct ieee80211_ops *ops,
|
|
|
|
const char *requested_name)
|
2007-05-06 02:45:53 +08:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local;
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 07:51:53 +08:00
|
|
|
int priv_size, i;
|
2007-05-06 02:45:53 +08:00
|
|
|
struct wiphy *wiphy;
|
2012-07-26 20:55:08 +08:00
|
|
|
bool use_chanctx;
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2012-07-26 20:42:10 +08:00
|
|
|
if (WARN_ON(!ops->tx || !ops->start || !ops->stop || !ops->config ||
|
|
|
|
!ops->add_interface || !ops->remove_interface ||
|
|
|
|
!ops->configure_filter))
|
|
|
|
return NULL;
|
|
|
|
|
2012-01-20 20:55:21 +08:00
|
|
|
if (WARN_ON(ops->sta_state && (ops->sta_add || ops->sta_remove)))
|
|
|
|
return NULL;
|
|
|
|
|
2012-07-26 20:46:32 +08:00
|
|
|
/* 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;
|
2012-07-26 20:55:08 +08:00
|
|
|
use_chanctx = i == 5;
|
2012-07-26 20:46:32 +08:00
|
|
|
|
2007-05-06 02:45:53 +08:00
|
|
|
/* 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 |
|
|
|
|
* +-------------------------+
|
|
|
|
*
|
|
|
|
*/
|
2009-05-27 12:42:37 +08:00
|
|
|
priv_size = ALIGN(sizeof(*local), NETDEV_ALIGN) + priv_data_len;
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2014-10-23 03:23:01 +08:00
|
|
|
wiphy = wiphy_new_nm(&mac80211_config_ops, priv_size, requested_name);
|
2007-05-06 02:45:53 +08:00
|
|
|
|
|
|
|
if (!wiphy)
|
|
|
|
return NULL;
|
|
|
|
|
2010-08-12 21:38:38 +08:00
|
|
|
wiphy->mgmt_stypes = ieee80211_default_mgmt_stypes;
|
|
|
|
|
2010-12-11 00:10:44 +08:00
|
|
|
wiphy->privid = mac80211_wiphy_privid;
|
|
|
|
|
2009-11-19 18:55:19 +08:00
|
|
|
wiphy->flags |= WIPHY_FLAG_NETNS_OK |
|
|
|
|
WIPHY_FLAG_4ADDR_AP |
|
2011-11-04 18:18:18 +08:00
|
|
|
WIPHY_FLAG_4ADDR_STATION |
|
2011-11-18 22:33:48 +08:00
|
|
|
WIPHY_FLAG_REPORTS_OBSS |
|
2012-03-27 00:47:18 +08:00
|
|
|
WIPHY_FLAG_OFFCHAN_TX;
|
|
|
|
|
|
|
|
if (ops->remain_on_channel)
|
|
|
|
wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
|
2010-12-11 00:10:44 +08:00
|
|
|
|
2012-10-12 16:55:53 +08:00
|
|
|
wiphy->features |= NL80211_FEATURE_SK_TX_STATUS |
|
|
|
|
NL80211_FEATURE_SAE |
|
2012-10-24 16:59:25 +08:00
|
|
|
NL80211_FEATURE_HT_IBSS |
|
2013-03-05 05:06:12 +08:00
|
|
|
NL80211_FEATURE_VIF_TXPOWER |
|
2014-10-23 03:23:06 +08:00
|
|
|
NL80211_FEATURE_MAC_ON_CREATE |
|
2015-11-26 23:26:14 +08:00
|
|
|
NL80211_FEATURE_USERSPACE_MPM |
|
|
|
|
NL80211_FEATURE_FULL_AP_CLIENT_STATE;
|
2016-10-27 05:42:06 +08:00
|
|
|
wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_FILS_STA);
|
2018-03-27 01:52:51 +08:00
|
|
|
wiphy_ext_feature_set(wiphy,
|
|
|
|
NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211);
|
2011-11-06 21:13:34 +08:00
|
|
|
|
2018-05-28 21:47:41 +08:00
|
|
|
if (!ops->hw_scan) {
|
2012-10-16 14:39:22 +08:00
|
|
|
wiphy->features |= NL80211_FEATURE_LOW_PRIORITY_SCAN |
|
|
|
|
NL80211_FEATURE_AP_SCAN;
|
2018-05-28 21:47:41 +08:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
2012-10-12 12:03:35 +08:00
|
|
|
|
2010-12-11 00:10:44 +08:00
|
|
|
if (!ops->set_key)
|
|
|
|
wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
|
2009-03-31 18:12:05 +08:00
|
|
|
|
2018-05-08 19:03:50 +08:00
|
|
|
if (ops->wake_tx_queue)
|
|
|
|
wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_TXQS);
|
|
|
|
|
2016-03-09 16:08:27 +08:00
|
|
|
wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_RRM);
|
|
|
|
|
2009-12-23 20:15:39 +08:00
|
|
|
wiphy->bss_priv_size = sizeof(struct ieee80211_bss);
|
2007-05-06 02:45:53 +08:00
|
|
|
|
|
|
|
local = wiphy_priv(wiphy);
|
2009-04-01 17:58:36 +08:00
|
|
|
|
2015-02-14 04:55:15 +08:00
|
|
|
if (sta_info_init(local))
|
|
|
|
goto err_free;
|
|
|
|
|
2007-05-06 02:45:53 +08:00
|
|
|
local->hw.wiphy = wiphy;
|
|
|
|
|
2009-05-27 12:42:37 +08:00
|
|
|
local->hw.priv = (char *)local + ALIGN(sizeof(*local), NETDEV_ALIGN);
|
2007-05-06 02:45:53 +08:00
|
|
|
|
|
|
|
local->ops = ops;
|
2012-07-26 20:55:08 +08:00
|
|
|
local->use_chanctx = use_chanctx;
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2018-08-08 18:40:01 +08:00
|
|
|
/*
|
|
|
|
* 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 8 is ~4ms 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 = 8;
|
|
|
|
|
2008-10-21 18:40:02 +08:00
|
|
|
/* set up some defaults */
|
|
|
|
local->hw.queues = 1;
|
|
|
|
local->hw.max_rates = 1;
|
2010-10-02 17:31:55 +08:00
|
|
|
local->hw.max_report_rates = 0;
|
2018-06-19 04:39:29 +08:00
|
|
|
local->hw.max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HT;
|
|
|
|
local->hw.max_tx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HT;
|
2012-04-03 22:28:50 +08:00
|
|
|
local->hw.offchannel_tx_hw_queue = IEEE80211_INVAL_HW_QUEUE;
|
2009-04-21 00:39:05 +08:00
|
|
|
local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
|
|
|
|
local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
|
2012-05-10 15:09:10 +08:00
|
|
|
local->hw.radiotap_mcs_details = IEEE80211_RADIOTAP_MCS_HAVE_MCS |
|
|
|
|
IEEE80211_RADIOTAP_MCS_HAVE_GI |
|
|
|
|
IEEE80211_RADIOTAP_MCS_HAVE_BW;
|
2012-11-23 06:00:18 +08:00
|
|
|
local->hw.radiotap_vht_details = IEEE80211_RADIOTAP_VHT_KNOWN_GI |
|
|
|
|
IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH;
|
2013-01-22 22:52:23 +08:00
|
|
|
local->hw.uapsd_queues = IEEE80211_DEFAULT_UAPSD_QUEUES;
|
|
|
|
local->hw.uapsd_max_sp_len = IEEE80211_DEFAULT_MAX_SP_LEN;
|
2012-10-24 16:59:25 +08:00
|
|
|
local->user_power_level = IEEE80211_UNSET_POWER_LEVEL;
|
2011-11-19 03:32:00 +08:00
|
|
|
wiphy->ht_capa_mod_mask = &mac80211_ht_capa_mod_mask;
|
2013-02-22 00:40:19 +08:00
|
|
|
wiphy->vht_capa_mod_mask = &mac80211_vht_capa_mod_mask;
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2014-10-08 14:48:36 +08:00
|
|
|
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);
|
|
|
|
|
2007-09-19 05:29:21 +08:00
|
|
|
INIT_LIST_HEAD(&local->interfaces);
|
2017-04-13 19:28:18 +08:00
|
|
|
INIT_LIST_HEAD(&local->mon_list);
|
2010-04-05 01:59:30 +08:00
|
|
|
|
|
|
|
__hw_addr_init(&local->mc_list);
|
|
|
|
|
2009-01-24 05:54:03 +08:00
|
|
|
mutex_init(&local->iflist_mtx);
|
2010-07-30 22:46:07 +08:00
|
|
|
mutex_init(&local->mtx);
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2010-06-01 16:19:19 +08:00
|
|
|
mutex_init(&local->key_mtx);
|
2009-06-17 23:43:56 +08:00
|
|
|
spin_lock_init(&local->filter_lock);
|
2013-02-05 01:44:44 +08:00
|
|
|
spin_lock_init(&local->rx_path_lock);
|
2008-12-19 05:35:20 +08:00
|
|
|
spin_lock_init(&local->queue_stop_reason_lock);
|
|
|
|
|
2012-06-26 20:37:16 +08:00
|
|
|
INIT_LIST_HEAD(&local->chanctx_list);
|
|
|
|
mutex_init(&local->chanctx_mtx);
|
|
|
|
|
2008-09-11 06:01:55 +08:00
|
|
|
INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work);
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2009-04-14 16:09:24 +08:00
|
|
|
INIT_WORK(&local->restart_work, ieee80211_restart_work);
|
|
|
|
|
2013-02-09 01:16:20 +08:00
|
|
|
INIT_WORK(&local->radar_detected_work,
|
|
|
|
ieee80211_dfs_radar_detected_work);
|
|
|
|
|
2009-08-17 22:16:53 +08:00
|
|
|
INIT_WORK(&local->reconfig_filter, ieee80211_reconfig_filter);
|
2009-12-01 20:37:02 +08:00
|
|
|
local->smps_mode = IEEE80211_SMPS_OFF;
|
2009-08-17 22:16:53 +08:00
|
|
|
|
2008-12-19 05:35:27 +08:00
|
|
|
INIT_WORK(&local->dynamic_ps_enable_work,
|
|
|
|
ieee80211_dynamic_ps_enable_work);
|
|
|
|
INIT_WORK(&local->dynamic_ps_disable_work,
|
|
|
|
ieee80211_dynamic_ps_disable_work);
|
2017-10-17 07:35:49 +08:00
|
|
|
timer_setup(&local->dynamic_ps_timer, ieee80211_dynamic_ps_timer, 0);
|
2008-12-19 05:35:27 +08:00
|
|
|
|
2011-05-12 21:28:29 +08:00
|
|
|
INIT_WORK(&local->sched_scan_stopped_work,
|
|
|
|
ieee80211_sched_scan_stopped_work);
|
|
|
|
|
2015-07-08 20:41:45 +08:00
|
|
|
INIT_WORK(&local->tdls_chsw_work, ieee80211_tdls_chsw_work);
|
|
|
|
|
2011-11-06 21:13:34 +08:00
|
|
|
spin_lock_init(&local->ack_status_lock);
|
|
|
|
idr_init(&local->ack_status_frames);
|
|
|
|
|
2010-06-10 16:21:41 +08:00
|
|
|
for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
|
2009-03-24 00:28:37 +08:00
|
|
|
skb_queue_head_init(&local->pending[i]);
|
2010-06-10 16:21:41 +08:00
|
|
|
atomic_set(&local->agg_queue_stop[i], 0);
|
|
|
|
}
|
2007-05-06 02:45:53 +08:00
|
|
|
tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending,
|
|
|
|
(unsigned long)local);
|
|
|
|
|
mac80211: add stop/start logic for software TXQs
Sometimes, it is required to stop the transmissions momentarily and
resume it later; stopping the txqs becomes very critical in scenarios where
the packet transmission has to be ceased completely. For example, during
the hardware restart, during off channel operations,
when initiating CSA(upon detecting a radar on the DFS channel), etc.
The TX queue stop/start logic in mac80211 works well in stopping the TX
when drivers make use of netdev queues, i.e, when Qdiscs in network layer
take care of traffic scheduling. Since the devices implementing
wake_tx_queue can run without Qdiscs, packets will be handed to mac80211
directly without queueing them in the netdev queues.
Also, mac80211 does not invoke any of the
netif_stop_*/netif_wake_* APIs if wake_tx_queue is implemented.
Since the queues are not stopped in this case, transmissions can continue
and this will impact negatively on the operation of the wireless device.
For example,
During hardware restart, we stop the netdev queues so that packets are
not sent to the driver. Since ath10k implements wake_tx_queue,
TX queues will not be stopped and packets might reach the hardware while
it is restarting; this can make hardware unresponsive and the only
possible option for recovery is to reboot the entire system.
There is another problem to this, it is observed that the packets
were sent on the DFS channel for a prolonged duration after radar
detection impacting the channel closing time.
We can still invoke netif stop/wake APIs when wake_tx_queue is implemented
but this could lead to packet drops in network layer; adding stop/start
logic for software TXQs in mac80211 instead makes more sense; the change
proposed adds the same in mac80211.
Signed-off-by: Manikanta Pubbisetty <mpubbise@codeaurora.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2018-07-11 02:42:53 +08:00
|
|
|
if (ops->wake_tx_queue)
|
|
|
|
tasklet_init(&local->wake_txqs_tasklet, ieee80211_wake_txqs,
|
|
|
|
(unsigned long)local);
|
|
|
|
|
2007-05-06 02:45:53 +08:00
|
|
|
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);
|
2015-07-08 20:41:45 +08:00
|
|
|
skb_queue_head_init(&local->skb_queue_tdls_chsw);
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2015-04-23 18:19:22 +08:00
|
|
|
ieee80211_alloc_led_names(local);
|
2010-11-28 03:02:59 +08:00
|
|
|
|
mac80211: unify SW/offload remain-on-channel
Redesign all the off-channel code, getting rid of
the generic off-channel work concept, replacing
it with a simple remain-on-channel list.
This fixes a number of small issues with the ROC
implementation:
* offloaded remain-on-channel couldn't be queued,
now we can queue it as well, if needed
* in iwlwifi (the only user) offloaded ROC is
mutually exclusive with scanning, use the new
queue to handle that case -- I expect that it
will later depend on a HW flag
The bigger issue though is that there's a bad bug
in the current implementation: if we get a mgmt
TX request while HW roc is active, and this new
request has a wait time, we actually schedule a
software ROC instead since we can't guarantee the
existing offloaded ROC will still be that long.
To fix this, the queuing mechanism was needed.
The queuing mechanism for offloaded ROC isn't yet
optimal, ideally we should add API to have the HW
extend the ROC if needed. We could add that later
but for now use a software implementation.
Overall, this unifies the behaviour between the
offloaded and software-implemented case as much
as possible.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-06-05 20:28:42 +08:00
|
|
|
ieee80211_roc_setup(local);
|
2010-12-19 00:20:47 +08:00
|
|
|
|
2016-08-30 04:25:17 +08:00
|
|
|
local->hw.radiotap_timestamp.units_pos = -1;
|
|
|
|
local->hw.radiotap_timestamp.accuracy = -1;
|
|
|
|
|
2012-02-26 18:24:35 +08:00
|
|
|
return &local->hw;
|
2015-02-14 04:55:15 +08:00
|
|
|
err_free:
|
|
|
|
wiphy_free(wiphy);
|
|
|
|
return NULL;
|
2007-05-06 02:45:53 +08:00
|
|
|
}
|
2014-10-23 03:23:01 +08:00
|
|
|
EXPORT_SYMBOL(ieee80211_alloc_hw_nm);
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2013-03-24 20:23:27 +08:00
|
|
|
static int ieee80211_init_cipher_suites(struct ieee80211_local *local)
|
2007-05-06 02:45:53 +08:00
|
|
|
{
|
2013-03-24 20:23:27 +08:00
|
|
|
bool have_wep = !(IS_ERR(local->wep_tx_tfm) ||
|
|
|
|
IS_ERR(local->wep_rx_tfm));
|
2015-06-03 03:39:54 +08:00
|
|
|
bool have_mfp = ieee80211_hw_check(&local->hw, MFP_CAPABLE);
|
2013-03-24 20:23:27 +08:00
|
|
|
int n_suites = 0, r = 0, w = 0;
|
|
|
|
u32 *suites;
|
2009-04-03 02:14:06 +08:00
|
|
|
static const u32 cipher_suites[] = {
|
2010-08-10 15:46:41 +08:00
|
|
|
/* keep WEP first, it may be removed below */
|
2009-04-03 02:14:06 +08:00
|
|
|
WLAN_CIPHER_SUITE_WEP40,
|
|
|
|
WLAN_CIPHER_SUITE_WEP104,
|
|
|
|
WLAN_CIPHER_SUITE_TKIP,
|
|
|
|
WLAN_CIPHER_SUITE_CCMP,
|
2015-01-25 01:52:07 +08:00
|
|
|
WLAN_CIPHER_SUITE_CCMP_256,
|
2015-01-25 01:52:06 +08:00
|
|
|
WLAN_CIPHER_SUITE_GCMP,
|
|
|
|
WLAN_CIPHER_SUITE_GCMP_256,
|
2009-04-03 02:14:06 +08:00
|
|
|
|
|
|
|
/* keep last -- depends on hw flags! */
|
2015-01-25 01:52:08 +08:00
|
|
|
WLAN_CIPHER_SUITE_AES_CMAC,
|
|
|
|
WLAN_CIPHER_SUITE_BIP_CMAC_256,
|
2015-01-25 01:52:09 +08:00
|
|
|
WLAN_CIPHER_SUITE_BIP_GMAC_128,
|
|
|
|
WLAN_CIPHER_SUITE_BIP_GMAC_256,
|
2009-04-03 02:14:06 +08:00
|
|
|
};
|
2008-01-25 02:38:38 +08:00
|
|
|
|
2015-06-03 03:39:54 +08:00
|
|
|
if (ieee80211_hw_check(&local->hw, SW_CRYPTO_CONTROL) ||
|
2015-01-23 01:44:19 +08:00
|
|
|
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;
|
2013-03-24 20:23:27 +08:00
|
|
|
|
2015-01-23 01:44:19 +08:00
|
|
|
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.
|
|
|
|
*/
|
2013-03-24 20:23:27 +08:00
|
|
|
local->hw.wiphy->cipher_suites = cipher_suites;
|
|
|
|
local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
|
|
|
|
|
|
|
|
if (!have_mfp)
|
2015-01-25 01:52:09 +08:00
|
|
|
local->hw.wiphy->n_cipher_suites -= 4;
|
2013-03-24 20:23:27 +08:00
|
|
|
|
|
|
|
if (!have_wep) {
|
|
|
|
local->hw.wiphy->cipher_suites += 2;
|
|
|
|
local->hw.wiphy->n_cipher_suites -= 2;
|
|
|
|
}
|
|
|
|
|
2015-01-23 01:44:19 +08:00
|
|
|
/* not dynamically allocated, so just return */
|
2013-03-24 20:23:27 +08:00
|
|
|
return 0;
|
2015-01-23 01:44:19 +08:00
|
|
|
} else {
|
|
|
|
const struct ieee80211_cipher_scheme *cs;
|
2013-03-24 20:23:27 +08:00
|
|
|
|
2015-01-23 01:44:19 +08:00
|
|
|
cs = local->hw.cipher_schemes;
|
|
|
|
|
|
|
|
/* Driver specifies cipher schemes only (but not cipher suites
|
|
|
|
* including the schemes)
|
|
|
|
*
|
2015-01-25 01:52:06 +08:00
|
|
|
* We start counting ciphers defined by schemes, TKIP, CCMP,
|
2015-01-25 01:52:07 +08:00
|
|
|
* CCMP-256, GCMP, and GCMP-256
|
2013-03-24 20:23:27 +08:00
|
|
|
*/
|
2015-01-25 01:52:07 +08:00
|
|
|
n_suites = local->hw.n_cipher_schemes + 5;
|
2013-03-24 20:23:27 +08:00
|
|
|
|
|
|
|
/* check if we have WEP40 and WEP104 */
|
|
|
|
if (have_wep)
|
|
|
|
n_suites += 2;
|
|
|
|
|
2015-01-25 01:52:09 +08:00
|
|
|
/* check if we have AES_CMAC, BIP-CMAC-256, BIP-GMAC-128,
|
|
|
|
* BIP-GMAC-256
|
|
|
|
*/
|
2013-03-24 20:23:27 +08:00
|
|
|
if (have_mfp)
|
2015-01-25 01:52:09 +08:00
|
|
|
n_suites += 4;
|
2013-03-24 20:23:27 +08:00
|
|
|
|
treewide: kmalloc() -> kmalloc_array()
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This
patch replaces cases of:
kmalloc(a * b, gfp)
with:
kmalloc_array(a * b, gfp)
as well as handling cases of:
kmalloc(a * b * c, gfp)
with:
kmalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kmalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kmalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The tools/ directory was manually excluded, since it has its own
implementation of kmalloc().
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kmalloc
+ kmalloc_array
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kmalloc(sizeof(THING) * C2, ...)
|
kmalloc(sizeof(TYPE) * C2, ...)
|
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(C1 * C2, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * E2
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-13 04:55:00 +08:00
|
|
|
suites = kmalloc_array(n_suites, sizeof(u32), GFP_KERNEL);
|
2013-03-24 20:23:27 +08:00
|
|
|
if (!suites)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
suites[w++] = WLAN_CIPHER_SUITE_CCMP;
|
2015-01-25 01:52:07 +08:00
|
|
|
suites[w++] = WLAN_CIPHER_SUITE_CCMP_256;
|
2013-03-24 20:23:27 +08:00
|
|
|
suites[w++] = WLAN_CIPHER_SUITE_TKIP;
|
2015-01-25 01:52:06 +08:00
|
|
|
suites[w++] = WLAN_CIPHER_SUITE_GCMP;
|
|
|
|
suites[w++] = WLAN_CIPHER_SUITE_GCMP_256;
|
2013-03-24 20:23:27 +08:00
|
|
|
|
|
|
|
if (have_wep) {
|
|
|
|
suites[w++] = WLAN_CIPHER_SUITE_WEP40;
|
|
|
|
suites[w++] = WLAN_CIPHER_SUITE_WEP104;
|
|
|
|
}
|
|
|
|
|
2015-01-25 01:52:08 +08:00
|
|
|
if (have_mfp) {
|
2013-03-24 20:23:27 +08:00
|
|
|
suites[w++] = WLAN_CIPHER_SUITE_AES_CMAC;
|
2015-01-25 01:52:08 +08:00
|
|
|
suites[w++] = WLAN_CIPHER_SUITE_BIP_CMAC_256;
|
2015-01-25 01:52:09 +08:00
|
|
|
suites[w++] = WLAN_CIPHER_SUITE_BIP_GMAC_128;
|
|
|
|
suites[w++] = WLAN_CIPHER_SUITE_BIP_GMAC_256;
|
2015-01-25 01:52:08 +08:00
|
|
|
}
|
2013-03-24 20:23:27 +08:00
|
|
|
|
2015-05-05 22:32:29 +08:00
|
|
|
for (r = 0; r < local->hw.n_cipher_schemes; r++) {
|
2013-03-24 20:23:27 +08:00
|
|
|
suites[w++] = cs[r].cipher;
|
2015-05-20 17:31:47 +08:00
|
|
|
if (WARN_ON(cs[r].pn_len > IEEE80211_MAX_PN_LEN)) {
|
|
|
|
kfree(suites);
|
2015-05-05 22:32:29 +08:00
|
|
|
return -EINVAL;
|
2015-05-20 17:31:47 +08:00
|
|
|
}
|
2015-05-05 22:32:29 +08:00
|
|
|
}
|
2013-03-24 20:23:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2016-04-12 21:56:15 +08:00
|
|
|
enum nl80211_band band;
|
2013-03-24 20:23:27 +08:00
|
|
|
int channels, max_bitrates;
|
2018-06-09 14:14:44 +08:00
|
|
|
bool supp_ht, supp_vht, supp_he;
|
2013-03-24 20:23:27 +08:00
|
|
|
netdev_features_t feature_whitelist;
|
|
|
|
struct cfg80211_chan_def dflt_chandef = {};
|
|
|
|
|
2015-06-03 03:39:54 +08:00
|
|
|
if (ieee80211_hw_check(hw, QUEUE_CONTROL) &&
|
2012-04-03 22:28:50 +08:00
|
|
|
(local->hw.offchannel_tx_hw_queue == IEEE80211_INVAL_HW_QUEUE ||
|
|
|
|
local->hw.offchannel_tx_hw_queue >= local->hw.queues))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2014-11-10 00:50:19 +08:00
|
|
|
if ((hw->wiphy->features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH) &&
|
|
|
|
(!local->ops->tdls_channel_switch ||
|
2014-11-10 00:50:20 +08:00
|
|
|
!local->ops->tdls_cancel_channel_switch ||
|
|
|
|
!local->ops->tdls_recv_channel_switch))
|
2014-11-10 00:50:19 +08:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2016-10-19 04:12:11 +08:00
|
|
|
if (WARN_ON(ieee80211_hw_check(hw, SUPPORTS_TX_FRAG) &&
|
|
|
|
!local->ops->set_frag_threshold))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2016-09-20 22:31:14 +08:00
|
|
|
if (WARN_ON(local->hw.wiphy->interface_modes &
|
|
|
|
BIT(NL80211_IFTYPE_NAN) &&
|
|
|
|
(!local->ops->start_nan || !local->ops->stop_nan)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-05-06 07:48:47 +08:00
|
|
|
#ifdef CONFIG_PM
|
2013-06-03 23:25:34 +08:00
|
|
|
if (hw->wiphy->wowlan && (!local->ops->suspend || !local->ops->resume))
|
2011-05-04 21:37:29 +08:00
|
|
|
return -EINVAL;
|
2012-06-27 15:23:48 +08:00
|
|
|
#endif
|
2011-05-04 21:37:29 +08:00
|
|
|
|
2012-07-26 20:55:08 +08:00
|
|
|
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;
|
|
|
|
}
|
2012-10-22 21:20:53 +08:00
|
|
|
} else {
|
2012-07-26 20:55:08 +08:00
|
|
|
/*
|
|
|
|
* 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;
|
2013-02-09 01:16:20 +08:00
|
|
|
|
2014-10-10 18:43:23 +08:00
|
|
|
/* DFS is not supported with multi-channel combinations yet */
|
2013-02-09 01:16:20 +08:00
|
|
|
for (i = 0; i < local->hw.wiphy->n_iface_combinations; i++) {
|
|
|
|
const struct ieee80211_iface_combination *comb;
|
|
|
|
|
|
|
|
comb = &local->hw.wiphy->iface_combinations[i];
|
|
|
|
|
2014-10-10 18:43:23 +08:00
|
|
|
if (comb->radar_detect_widths &&
|
|
|
|
comb->num_different_channels > 1)
|
2013-02-09 01:16:20 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2012-07-26 20:55:08 +08:00
|
|
|
}
|
|
|
|
|
2012-05-10 21:18:26 +08:00
|
|
|
/* Only HW csum features are currently compatible with mac80211 */
|
|
|
|
feature_whitelist = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
|
2015-04-14 20:50:41 +08:00
|
|
|
NETIF_F_HW_CSUM | NETIF_F_SG | NETIF_F_HIGHDMA |
|
2016-03-09 19:27:08 +08:00
|
|
|
NETIF_F_GSO_SOFTWARE | NETIF_F_RXCSUM;
|
2012-05-10 21:18:26 +08:00
|
|
|
if (WARN_ON(hw->netdev_features & ~feature_whitelist))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-10-02 17:31:55 +08:00
|
|
|
if (hw->max_report_rates == 0)
|
|
|
|
hw->max_report_rates = hw->max_rates;
|
|
|
|
|
2012-09-11 20:34:12 +08:00
|
|
|
local->rx_chains = 1;
|
|
|
|
|
2008-01-25 02:38:38 +08:00
|
|
|
/*
|
|
|
|
* generic code guarantees at least one band,
|
|
|
|
* set this very early because much code assumes
|
|
|
|
* that hw.conf.channel is assigned
|
|
|
|
*/
|
2009-02-11 04:25:55 +08:00
|
|
|
channels = 0;
|
2009-04-01 17:58:36 +08:00
|
|
|
max_bitrates = 0;
|
2009-03-31 18:12:07 +08:00
|
|
|
supp_ht = false;
|
2012-07-02 19:25:12 +08:00
|
|
|
supp_vht = false;
|
2018-06-09 14:14:44 +08:00
|
|
|
supp_he = false;
|
2016-04-12 21:56:15 +08:00
|
|
|
for (band = 0; band < NUM_NL80211_BANDS; band++) {
|
2008-01-25 02:38:38 +08:00
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
|
|
|
sband = local->hw.wiphy->bands[band];
|
2009-04-01 17:58:36 +08:00
|
|
|
if (!sband)
|
|
|
|
continue;
|
2013-04-16 01:04:06 +08:00
|
|
|
|
|
|
|
if (!dflt_chandef.chan) {
|
|
|
|
cfg80211_chandef_create(&dflt_chandef,
|
|
|
|
&sband->channels[0],
|
|
|
|
NL80211_CHAN_NO_HT);
|
2008-01-25 02:38:38 +08:00
|
|
|
/* init channel we're on */
|
2013-04-16 01:04:06 +08:00
|
|
|
if (!local->use_chanctx && !local->_oper_chandef.chan) {
|
|
|
|
local->hw.conf.chandef = dflt_chandef;
|
|
|
|
local->_oper_chandef = dflt_chandef;
|
|
|
|
}
|
|
|
|
local->monitor_chandef = dflt_chandef;
|
2008-01-25 02:38:38 +08:00
|
|
|
}
|
2013-04-16 01:04:06 +08:00
|
|
|
|
2009-04-01 17:58:36 +08:00
|
|
|
channels += sband->n_channels;
|
|
|
|
|
|
|
|
if (max_bitrates < sband->n_bitrates)
|
|
|
|
max_bitrates = sband->n_bitrates;
|
2009-03-31 18:12:07 +08:00
|
|
|
supp_ht = supp_ht || sband->ht_cap.ht_supported;
|
2012-07-02 19:25:12 +08:00
|
|
|
supp_vht = supp_vht || sband->vht_cap.vht_supported;
|
2012-09-11 20:34:12 +08:00
|
|
|
|
2018-06-09 14:14:44 +08:00
|
|
|
if (!supp_he)
|
|
|
|
supp_he = !!ieee80211_get_he_sta_cap(sband);
|
|
|
|
|
2017-01-13 18:28:25 +08:00
|
|
|
if (!sband->ht_cap.ht_supported)
|
|
|
|
continue;
|
2012-09-11 20:34:12 +08:00
|
|
|
|
|
|
|
/* TODO: consider VHT for RX chains, hopefully it's the same */
|
2017-01-13 18:28:25 +08:00
|
|
|
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;
|
2008-01-25 02:38:38 +08:00
|
|
|
}
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2018-03-28 21:04:19 +08:00
|
|
|
/* 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)) {
|
2011-05-13 16:58:57 +08:00
|
|
|
hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN);
|
|
|
|
hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_AP_VLAN);
|
|
|
|
}
|
2008-08-30 07:26:43 +08:00
|
|
|
|
|
|
|
/* mac80211 always supports monitor */
|
2011-05-13 16:58:57 +08:00
|
|
|
hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR);
|
|
|
|
hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_MONITOR);
|
|
|
|
|
2012-07-26 23:24:39 +08:00
|
|
|
/* mac80211 doesn't support more than one IBSS interface right now */
|
2011-05-14 07:55:23 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-01-06 23:02:34 +08:00
|
|
|
local->int_scan_req = kzalloc(sizeof(*local->int_scan_req) +
|
|
|
|
sizeof(void *) * channels, GFP_KERNEL);
|
|
|
|
if (!local->int_scan_req)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2016-04-12 21:56:15 +08:00
|
|
|
for (band = 0; band < NUM_NL80211_BANDS; band++) {
|
2014-01-06 23:02:34 +08:00
|
|
|
if (!local->hw.wiphy->bands[band])
|
|
|
|
continue;
|
|
|
|
local->int_scan_req->rates[band] = (u32) -1;
|
|
|
|
}
|
|
|
|
|
2010-08-25 20:34:01 +08:00
|
|
|
#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
|
|
|
|
|
2011-04-08 06:08:35 +08:00
|
|
|
/* 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;
|
|
|
|
|
2010-08-27 19:26:54 +08:00
|
|
|
/* mac80211 supports control port protocol changing */
|
|
|
|
local->hw.wiphy->flags |= WIPHY_FLAG_CONTROL_PORT_PROTOCOL;
|
|
|
|
|
2015-06-03 03:39:54 +08:00
|
|
|
if (ieee80211_hw_check(&local->hw, SIGNAL_DBM)) {
|
2009-02-19 01:45:06 +08:00
|
|
|
local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
|
2015-06-03 03:39:54 +08:00
|
|
|
} else if (ieee80211_hw_check(&local->hw, SIGNAL_UNSPEC)) {
|
2009-02-19 01:45:06 +08:00
|
|
|
local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC;
|
2014-01-20 05:21:49 +08:00
|
|
|
if (hw->max_signal <= 0) {
|
|
|
|
result = -EINVAL;
|
|
|
|
goto fail_wiphy_register;
|
|
|
|
}
|
|
|
|
}
|
2009-02-19 01:45:06 +08:00
|
|
|
|
2009-04-01 17:58:36 +08:00
|
|
|
/*
|
|
|
|
* Calculate scan IE length -- we need this to alloc
|
|
|
|
* memory and to subtract from the driver limit. It
|
2010-10-27 18:40:33 +08:00
|
|
|
* includes the DS Params, (extended) supported rates, and HT
|
2009-04-01 17:58:36 +08:00
|
|
|
* information -- SSID is the driver's responsibility.
|
|
|
|
*/
|
2010-10-27 18:40:33 +08:00
|
|
|
local->scan_ies_len = 4 + max_bitrates /* (ext) supp rates */ +
|
|
|
|
3 /* DS Params */;
|
2009-03-31 18:12:07 +08:00
|
|
|
if (supp_ht)
|
|
|
|
local->scan_ies_len += 2 + sizeof(struct ieee80211_ht_cap);
|
2009-04-01 17:58:36 +08:00
|
|
|
|
2013-03-25 23:26:58 +08:00
|
|
|
if (supp_vht)
|
2012-07-02 19:25:12 +08:00
|
|
|
local->scan_ies_len +=
|
2012-10-10 19:25:40 +08:00
|
|
|
2 + sizeof(struct ieee80211_vht_cap);
|
2012-07-02 19:25:12 +08:00
|
|
|
|
2018-06-09 14:14:44 +08:00
|
|
|
/* 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;
|
|
|
|
|
2009-04-01 17:58:36 +08:00
|
|
|
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;
|
|
|
|
|
2013-03-24 20:23:27 +08:00
|
|
|
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;
|
2009-04-03 02:14:06 +08:00
|
|
|
|
2010-12-19 00:20:47 +08:00
|
|
|
if (!local->ops->remain_on_channel)
|
|
|
|
local->hw.wiphy->max_remain_on_channel_duration = 5000;
|
2010-12-15 00:54:28 +08:00
|
|
|
|
2011-09-28 19:12:52 +08:00
|
|
|
/* 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;
|
|
|
|
|
2014-10-08 14:48:36 +08:00
|
|
|
/* mac80211 supports eCSA, if the driver supports STA CSA at all */
|
2015-06-03 03:39:54 +08:00
|
|
|
if (ieee80211_hw_check(&local->hw, CHANCTX_STA_CSA))
|
2014-10-08 14:48:36 +08:00
|
|
|
local->ext_capa[0] |= WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING;
|
|
|
|
|
2014-05-09 19:11:47 +08:00
|
|
|
local->hw.wiphy->max_num_csa_counters = IEEE80211_MAX_CSA_COUNTERS_NUM;
|
|
|
|
|
2007-05-06 02:45:53 +08:00
|
|
|
result = wiphy_register(local->hw.wiphy);
|
|
|
|
if (result < 0)
|
2009-02-11 04:25:55 +08:00
|
|
|
goto fail_wiphy_register;
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2008-05-17 06:57:14 +08:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
2009-07-30 08:08:07 +08:00
|
|
|
local->workqueue =
|
2013-07-04 06:04:57 +08:00
|
|
|
alloc_ordered_workqueue("%s", 0, wiphy_name(local->hw.wiphy));
|
2009-07-30 08:08:07 +08:00
|
|
|
if (!local->workqueue) {
|
2007-05-06 02:45:53 +08:00
|
|
|
result = -ENOMEM;
|
|
|
|
goto fail_workqueue;
|
|
|
|
}
|
|
|
|
|
2007-07-11 01:32:08 +08:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2007-07-18 23:10:44 +08:00
|
|
|
local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom,
|
2011-10-12 00:08:54 +08:00
|
|
|
IEEE80211_TX_STATUS_HEADROOM);
|
2007-07-11 01:32:08 +08:00
|
|
|
|
2007-05-06 02:46:38 +08:00
|
|
|
debugfs_hw_add(local);
|
|
|
|
|
2010-02-24 21:19:37 +08:00
|
|
|
/*
|
|
|
|
* if the driver doesn't specify a max listen interval we
|
|
|
|
* use 5 which should be a safe default
|
|
|
|
*/
|
2008-07-18 13:53:00 +08:00
|
|
|
if (local->hw.max_listen_interval == 0)
|
2010-02-24 21:19:37 +08:00
|
|
|
local->hw.max_listen_interval = 5;
|
2008-07-18 13:53:00 +08:00
|
|
|
|
|
|
|
local->hw.conf.listen_interval = local->hw.max_listen_interval;
|
|
|
|
|
2010-06-09 14:51:52 +08:00
|
|
|
local->dynamic_ps_forced_timeout = -1;
|
2010-04-27 17:47:40 +08:00
|
|
|
|
2016-09-20 22:31:20 +08:00
|
|
|
if (!local->hw.max_nan_de_entries)
|
|
|
|
local->hw.max_nan_de_entries = IEEE80211_MAX_NAN_INSTANCE_ID;
|
|
|
|
|
2009-04-29 18:41:24 +08:00
|
|
|
result = ieee80211_wep_init(local);
|
2010-07-08 03:07:49 +08:00
|
|
|
if (result < 0)
|
2010-08-21 07:25:38 +08:00
|
|
|
wiphy_debug(local->hw.wiphy, "Failed to initialize wep: %d\n",
|
|
|
|
result);
|
2009-04-29 18:41:24 +08:00
|
|
|
|
2013-11-20 00:12:05 +08:00
|
|
|
local->hw.conf.flags = IEEE80211_CONF_IDLE;
|
|
|
|
|
2012-02-09 22:29:43 +08:00
|
|
|
ieee80211_led_init(local);
|
|
|
|
|
2018-05-25 20:29:21 +08:00
|
|
|
result = ieee80211_txq_setup_flows(local);
|
|
|
|
if (result)
|
|
|
|
goto fail_flows;
|
|
|
|
|
2007-05-06 02:45:53 +08:00
|
|
|
rtnl_lock();
|
|
|
|
|
2007-10-28 21:51:05 +08:00
|
|
|
result = ieee80211_init_rate_ctrl_alg(local,
|
|
|
|
hw->rate_control_algorithm);
|
2007-05-06 02:45:53 +08:00
|
|
|
if (result < 0) {
|
2010-08-21 07:25:38 +08:00
|
|
|
wiphy_debug(local->hw.wiphy,
|
|
|
|
"Failed to initialize rate control algorithm\n");
|
2007-05-06 02:45:53 +08:00
|
|
|
goto fail_rate;
|
|
|
|
}
|
|
|
|
|
2018-08-31 16:31:17 +08:00
|
|
|
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);
|
2018-09-26 20:17:17 +08:00
|
|
|
if (!sband) {
|
|
|
|
result = -ENOMEM;
|
2018-08-31 16:31:17 +08:00
|
|
|
goto fail_rate;
|
2018-09-26 20:17:17 +08:00
|
|
|
}
|
2018-08-31 16:31:17 +08:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2008-12-09 07:10:30 +08:00
|
|
|
/* add one default STA interface if supported */
|
2014-10-23 03:23:03 +08:00
|
|
|
if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION) &&
|
2015-06-03 03:39:54 +08:00
|
|
|
!ieee80211_hw_check(hw, NO_AUTO_VIF)) {
|
2018-12-15 17:03:11 +08:00
|
|
|
struct vif_params params = {0};
|
|
|
|
|
2015-03-18 18:13:39 +08:00
|
|
|
result = ieee80211_if_add(local, "wlan%d", NET_NAME_ENUM, NULL,
|
2018-12-15 17:03:11 +08:00
|
|
|
NL80211_IFTYPE_STATION, ¶ms);
|
2008-12-09 07:10:30 +08:00
|
|
|
if (result)
|
2010-08-21 07:25:38 +08:00
|
|
|
wiphy_warn(local->hw.wiphy,
|
|
|
|
"Failed to add default virtual iface\n");
|
2008-12-09 07:10:30 +08:00
|
|
|
}
|
2007-05-06 02:45:53 +08:00
|
|
|
|
|
|
|
rtnl_unlock();
|
|
|
|
|
2010-06-05 02:25:44 +08:00
|
|
|
#ifdef CONFIG_INET
|
2010-05-27 20:32:13 +08:00
|
|
|
local->ifa_notifier.notifier_call = ieee80211_ifa_changed;
|
|
|
|
result = register_inetaddr_notifier(&local->ifa_notifier);
|
|
|
|
if (result)
|
|
|
|
goto fail_ifa;
|
2010-06-05 02:25:44 +08:00
|
|
|
#endif
|
2010-05-27 20:32:13 +08:00
|
|
|
|
2013-01-14 22:14:34 +08:00
|
|
|
#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
|
|
|
|
|
2007-05-06 02:45:53 +08:00
|
|
|
return 0;
|
|
|
|
|
2013-01-14 22:14:34 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
fail_ifa6:
|
2010-08-03 13:22:25 +08:00
|
|
|
#ifdef CONFIG_INET
|
2013-01-14 22:14:34 +08:00
|
|
|
unregister_inetaddr_notifier(&local->ifa_notifier);
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#if defined(CONFIG_INET) || defined(CONFIG_IPV6)
|
2010-05-27 20:32:13 +08:00
|
|
|
fail_ifa:
|
2010-08-03 13:22:25 +08:00
|
|
|
#endif
|
2015-01-21 20:52:24 +08:00
|
|
|
rtnl_lock();
|
|
|
|
rate_control_deinitialize(local);
|
2009-04-16 19:17:25 +08:00
|
|
|
ieee80211_remove_interfaces(local);
|
|
|
|
fail_rate:
|
2007-05-06 02:45:53 +08:00
|
|
|
rtnl_unlock();
|
2015-01-21 20:52:24 +08:00
|
|
|
ieee80211_led_exit(local);
|
2009-04-29 18:41:24 +08:00
|
|
|
ieee80211_wep_free(local);
|
2018-05-25 20:29:21 +08:00
|
|
|
fail_flows:
|
2009-07-30 08:08:07 +08:00
|
|
|
destroy_workqueue(local->workqueue);
|
2009-04-16 19:17:25 +08:00
|
|
|
fail_workqueue:
|
2007-05-06 02:45:53 +08:00
|
|
|
wiphy_unregister(local->hw.wiphy);
|
2009-04-16 19:17:25 +08:00
|
|
|
fail_wiphy_register:
|
2010-08-27 19:26:52 +08:00
|
|
|
if (local->wiphy_ciphers_allocated)
|
|
|
|
kfree(local->hw.wiphy->cipher_suites);
|
2009-08-20 01:45:50 +08:00
|
|
|
kfree(local->int_scan_req);
|
2007-05-06 02:45:53 +08:00
|
|
|
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);
|
|
|
|
|
2010-06-05 02:25:44 +08:00
|
|
|
#ifdef CONFIG_INET
|
2010-05-27 20:32:13 +08:00
|
|
|
unregister_inetaddr_notifier(&local->ifa_notifier);
|
2010-06-05 02:25:44 +08:00
|
|
|
#endif
|
2013-01-14 22:14:34 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
unregister_inet6addr_notifier(&local->ifa6_notifier);
|
|
|
|
#endif
|
2009-04-16 19:17:25 +08:00
|
|
|
|
2007-05-06 02:45:53 +08:00
|
|
|
rtnl_lock();
|
|
|
|
|
2007-09-19 05:29:21 +08:00
|
|
|
/*
|
|
|
|
* At this point, interface list manipulations are fine
|
|
|
|
* because the driver cannot be handing us frames any
|
|
|
|
* more and the tasklet is killed.
|
|
|
|
*/
|
2008-07-09 20:40:35 +08:00
|
|
|
ieee80211_remove_interfaces(local);
|
2007-09-26 20:27:23 +08:00
|
|
|
|
2007-05-06 02:45:53 +08:00
|
|
|
rtnl_unlock();
|
|
|
|
|
mac80211: rewrite remain-on-channel logic
Jouni found a bug in the remain-on-channel logic: when a short item
is queued, a long item is combined with it extending the original
one, and then the long item is deleted, the timeout doesn't go back
to the short one, and the short item ends up taking a long time. In
this case, this showed as blocking scan when running two test cases
back to back - the scan from the second was delayed even though all
the remain-on-channel items should long have been gone.
Fixing this with the current data structures turns out to be a bit
complicated, we just remove the long item from the dependents list
right now and don't recalculate the timeouts.
There's a somewhat similar bug where we delete the short item and
all the dependents go with it; to fix this we'd have to move them
from the dependents to the real list.
Instead of trying to do that, rewrite the code to not have all this
complexity in the data structures: use a single list and allow more
than one entry in it being marked as started. This makes the code a
bit more complex, the worker needs to understand that it might need
to just remove one of the started items, while keeping the device
off-channel, but that's not more complicated than the nested data
structures.
This then fixes both issues described, and makes it easier to also
limit the overall off-channel time when combining.
TODO: as before, with hardware remain-on-channel, deleting an item
after combining results in cancelling them all - we can keep track
of the time elapsed and only cancel after that to fix this.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2015-11-24 06:53:51 +08:00
|
|
|
cancel_delayed_work_sync(&local->roc_work);
|
2010-08-23 05:48:25 +08:00
|
|
|
cancel_work_sync(&local->restart_work);
|
2009-08-17 22:16:53 +08:00
|
|
|
cancel_work_sync(&local->reconfig_filter);
|
2015-07-08 20:41:45 +08:00
|
|
|
cancel_work_sync(&local->tdls_chsw_work);
|
2013-11-06 17:34:36 +08:00
|
|
|
flush_work(&local->sched_scan_stopped_work);
|
2017-04-26 15:58:53 +08:00
|
|
|
flush_work(&local->radar_detected_work);
|
2009-08-17 22:16:53 +08:00
|
|
|
|
2007-05-06 02:45:53 +08:00
|
|
|
ieee80211_clear_tx_pending(local);
|
|
|
|
rate_control_deinitialize(local);
|
|
|
|
|
2009-11-30 08:55:45 +08:00
|
|
|
if (skb_queue_len(&local->skb_queue) ||
|
|
|
|
skb_queue_len(&local->skb_queue_unreliable))
|
2010-08-21 07:25:38 +08:00
|
|
|
wiphy_warn(local->hw.wiphy, "skb_queue not empty\n");
|
2007-05-06 02:45:53 +08:00
|
|
|
skb_queue_purge(&local->skb_queue);
|
|
|
|
skb_queue_purge(&local->skb_queue_unreliable);
|
2015-07-08 20:41:45 +08:00
|
|
|
skb_queue_purge(&local->skb_queue_tdls_chsw);
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2009-07-30 08:08:07 +08:00
|
|
|
destroy_workqueue(local->workqueue);
|
2007-05-06 02:45:53 +08:00
|
|
|
wiphy_unregister(local->hw.wiphy);
|
|
|
|
ieee80211_wep_free(local);
|
|
|
|
ieee80211_led_exit(local);
|
2009-08-07 23:54:07 +08:00
|
|
|
kfree(local->int_scan_req);
|
2007-05-06 02:45:53 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_unregister_hw);
|
|
|
|
|
2011-11-06 21:13:34 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2007-05-06 02:45:53 +08:00
|
|
|
void ieee80211_free_hw(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
2018-08-31 16:31:17 +08:00
|
|
|
enum nl80211_band band;
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2009-01-24 05:54:03 +08:00
|
|
|
mutex_destroy(&local->iflist_mtx);
|
2010-07-30 22:46:07 +08:00
|
|
|
mutex_destroy(&local->mtx);
|
2009-01-24 05:54:03 +08:00
|
|
|
|
2010-08-27 19:26:52 +08:00
|
|
|
if (local->wiphy_ciphers_allocated)
|
|
|
|
kfree(local->hw.wiphy->cipher_suites);
|
|
|
|
|
2011-11-06 21:13:34 +08:00
|
|
|
idr_for_each(&local->ack_status_frames,
|
|
|
|
ieee80211_free_ack_frame, NULL);
|
|
|
|
idr_destroy(&local->ack_status_frames);
|
|
|
|
|
2015-01-21 20:52:24 +08:00
|
|
|
sta_info_stop(local);
|
|
|
|
|
2015-04-23 18:19:22 +08:00
|
|
|
ieee80211_free_led_names(local);
|
|
|
|
|
2018-08-31 16:31:17 +08:00
|
|
|
for (band = 0; band < NUM_NL80211_BANDS; band++) {
|
|
|
|
if (!(local->sband_allocated & BIT(band)))
|
|
|
|
continue;
|
|
|
|
kfree(local->hw.wiphy->bands[band]);
|
|
|
|
}
|
|
|
|
|
2007-05-06 02:45:53 +08:00
|
|
|
wiphy_free(local->hw.wiphy);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_free_hw);
|
|
|
|
|
|
|
|
static int __init ieee80211_init(void)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
int ret;
|
|
|
|
|
2008-05-15 18:55:29 +08:00
|
|
|
BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb));
|
|
|
|
BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) +
|
2008-10-07 18:04:32 +08:00
|
|
|
IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb));
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2008-10-06 00:07:45 +08:00
|
|
|
ret = rc80211_minstrel_init();
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2009-11-26 00:46:19 +08:00
|
|
|
ret = ieee80211_iface_init();
|
|
|
|
if (ret)
|
|
|
|
goto err_netdev;
|
2007-05-06 02:46:38 +08:00
|
|
|
|
2007-05-06 02:45:53 +08:00
|
|
|
return 0;
|
2009-11-26 00:46:19 +08:00
|
|
|
err_netdev:
|
|
|
|
rc80211_minstrel_exit();
|
|
|
|
|
|
|
|
return ret;
|
2007-05-06 02:45:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit ieee80211_exit(void)
|
|
|
|
{
|
2008-10-06 00:07:45 +08:00
|
|
|
rc80211_minstrel_exit();
|
2007-10-28 21:17:44 +08:00
|
|
|
|
2013-02-15 21:40:31 +08:00
|
|
|
ieee80211s_stop();
|
2008-02-23 22:17:19 +08:00
|
|
|
|
2009-11-26 00:46:19 +08:00
|
|
|
ieee80211_iface_exit();
|
2011-05-14 17:04:51 +08:00
|
|
|
|
|
|
|
rcu_barrier();
|
2007-05-06 02:45:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-09-11 18:50:32 +08:00
|
|
|
subsys_initcall(ieee80211_init);
|
2007-05-06 02:45:53 +08:00
|
|
|
module_exit(ieee80211_exit);
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION("IEEE 802.11 subsystem");
|
|
|
|
MODULE_LICENSE("GPL");
|