2007-05-05 18:45:53 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2002-2005, Instant802 Networks, Inc.
|
|
|
|
* Copyright 2005, Devicescape Software, Inc.
|
|
|
|
* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
|
2010-02-15 10:53:10 +00:00
|
|
|
* Copyright 2007-2010 Johannes Berg <johannes@sipsolutions.net>
|
2016-08-29 20:25:16 +00:00
|
|
|
* Copyright 2013-2015 Intel Mobile Communications GmbH
|
2007-05-05 18:45:53 +00: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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef IEEE80211_I_H
|
|
|
|
#define IEEE80211_I_H
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/if_ether.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/spinlock.h>
|
2007-07-27 13:43:22 +00:00
|
|
|
#include <linux/etherdevice.h>
|
2010-11-30 07:58:45 +00:00
|
|
|
#include <linux/leds.h>
|
2011-11-06 13:13:34 +00:00
|
|
|
#include <linux/idr.h>
|
2015-02-13 20:55:15 +00:00
|
|
|
#include <linux/rhashtable.h>
|
2009-11-18 17:42:47 +00:00
|
|
|
#include <net/ieee80211_radiotap.h>
|
2008-10-21 19:03:48 +00:00
|
|
|
#include <net/cfg80211.h>
|
2008-07-15 10:34:57 +00:00
|
|
|
#include <net/mac80211.h>
|
2016-05-19 08:37:49 +00:00
|
|
|
#include <net/fq.h>
|
2008-04-08 19:14:40 +00:00
|
|
|
#include "key.h"
|
2007-05-05 18:45:53 +00:00
|
|
|
#include "sta_info.h"
|
2012-06-22 09:29:50 +00:00
|
|
|
#include "debug.h"
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2015-10-14 16:36:43 +00:00
|
|
|
extern const struct cfg80211_ops mac80211_config_ops;
|
|
|
|
|
2008-04-03 13:17:31 +00:00
|
|
|
struct ieee80211_local;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
|
|
|
/* Maximum number of broadcast/multicast frames to buffer when some of the
|
|
|
|
* associated stations are using power saving. */
|
|
|
|
#define AP_MAX_BC_BUFFER 128
|
|
|
|
|
|
|
|
/* Maximum number of frames buffered to all STAs, including multicast frames.
|
|
|
|
* Note: increasing this limit increases the potential memory requirement. Each
|
|
|
|
* frame can be up to about 2 kB long. */
|
|
|
|
#define TOTAL_MAX_TX_BUFFER 512
|
|
|
|
|
|
|
|
/* Required encryption head and tailroom */
|
|
|
|
#define IEEE80211_ENCRYPT_HEADROOM 8
|
2009-01-08 11:32:01 +00:00
|
|
|
#define IEEE80211_ENCRYPT_TAILROOM 18
|
2007-05-05 18:45:53 +00:00
|
|
|
|
|
|
|
/* IEEE 802.11 (Ch. 9.5 Defragmentation) requires support for concurrent
|
|
|
|
* reception of at least three fragmented frames. This limit can be increased
|
|
|
|
* by changing this define, at the cost of slower frame reassembly and
|
|
|
|
* increased memory use (about 2 kB of RAM per entry). */
|
|
|
|
#define IEEE80211_FRAGMENT_MAX 4
|
|
|
|
|
2012-10-24 08:59:25 +00:00
|
|
|
/* power level hasn't been configured (or set to automatic) */
|
|
|
|
#define IEEE80211_UNSET_POWER_LEVEL INT_MIN
|
|
|
|
|
2012-06-18 07:43:50 +00:00
|
|
|
/*
|
2015-02-10 11:48:44 +00:00
|
|
|
* Some APs experience problems when working with U-APSD. Decreasing the
|
|
|
|
* probability of that happening by using legacy mode for all ACs but VO isn't
|
|
|
|
* enough.
|
|
|
|
*
|
|
|
|
* Cisco 4410N originally forced us to enable VO by default only because it
|
|
|
|
* treated non-VO ACs as legacy.
|
|
|
|
*
|
|
|
|
* However some APs (notably Netgear R7000) silently reclassify packets to
|
|
|
|
* different ACs. Since u-APSD ACs require trigger frames for frame retrieval
|
|
|
|
* clients would never see some frames (e.g. ARP responses) or would fetch them
|
|
|
|
* accidentally after a long time.
|
|
|
|
*
|
|
|
|
* It makes little sense to enable u-APSD queues by default because it needs
|
|
|
|
* userspace applications to be aware of it to actually take advantage of the
|
|
|
|
* possible additional powersavings. Implicitly depending on driver autotrigger
|
|
|
|
* frame support doesn't make much sense.
|
2012-06-18 07:43:50 +00:00
|
|
|
*/
|
2015-02-10 11:48:44 +00:00
|
|
|
#define IEEE80211_DEFAULT_UAPSD_QUEUES 0
|
2010-01-12 08:42:31 +00:00
|
|
|
|
|
|
|
#define IEEE80211_DEFAULT_MAX_SP_LEN \
|
|
|
|
IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL
|
|
|
|
|
2016-10-18 20:12:12 +00:00
|
|
|
extern const u8 ieee80211_ac_to_qos_mask[IEEE80211_NUM_ACS];
|
|
|
|
|
2012-09-07 11:28:52 +00:00
|
|
|
#define IEEE80211_DEAUTH_FRAME_LEN (24 /* hdr */ + 2 /* reason */)
|
|
|
|
|
2016-09-20 14:31:20 +00:00
|
|
|
#define IEEE80211_MAX_NAN_INSTANCE_ID 255
|
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
struct ieee80211_fragment_entry {
|
|
|
|
struct sk_buff_head skb_list;
|
2015-06-26 07:21:01 +00:00
|
|
|
unsigned long first_frag_time;
|
|
|
|
u16 seq;
|
|
|
|
u16 extra_len;
|
|
|
|
u16 last_frag;
|
|
|
|
u8 rx_queue;
|
2016-02-26 21:13:40 +00:00
|
|
|
bool check_sequential_pn; /* needed for CCMP/GCMP */
|
2007-05-05 18:45:53 +00:00
|
|
|
u8 last_pn[6]; /* PN of the last fragment if CCMP was used */
|
2021-05-31 20:31:27 +00:00
|
|
|
unsigned int key_color;
|
2007-05-05 18:45:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2008-09-10 22:01:55 +00:00
|
|
|
struct ieee80211_bss {
|
2013-02-05 16:48:40 +00:00
|
|
|
u32 device_ts_beacon, device_ts_presp;
|
2012-05-22 20:13:05 +00:00
|
|
|
|
2008-08-15 19:21:27 +00:00
|
|
|
bool wmm_used;
|
2010-01-12 08:42:31 +00:00
|
|
|
bool uapsd_supported;
|
2009-02-10 20:26:00 +00:00
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
#define IEEE80211_MAX_SUPP_RATES 32
|
|
|
|
u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
|
|
|
|
size_t supp_rates_len;
|
2013-05-19 11:23:57 +00:00
|
|
|
struct ieee80211_rate *beacon_rate;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2009-02-10 20:26:00 +00:00
|
|
|
/*
|
2011-03-31 01:57:33 +00:00
|
|
|
* During association, we save an ERP value from a probe response so
|
2007-07-10 17:32:10 +00:00
|
|
|
* that we can feed ERP info to the driver when handling the
|
|
|
|
* association completes. these fields probably won't be up-to-date
|
2009-02-10 20:26:00 +00:00
|
|
|
* otherwise, you probably don't want to use them.
|
|
|
|
*/
|
|
|
|
bool has_erp_value;
|
2007-07-10 17:32:10 +00:00
|
|
|
u8 erp_value;
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
|
|
|
|
/* Keep track of the corruption of the last beacon/probe response. */
|
|
|
|
u8 corrupt_data;
|
|
|
|
|
|
|
|
/* Keep track of what bits of information we have valid info for. */
|
|
|
|
u8 valid_data;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* enum ieee80211_corrupt_data_flags - BSS data corruption flags
|
|
|
|
* @IEEE80211_BSS_CORRUPT_BEACON: last beacon frame received was corrupted
|
|
|
|
* @IEEE80211_BSS_CORRUPT_PROBE_RESP: last probe response received was corrupted
|
|
|
|
*
|
|
|
|
* These are bss flags that are attached to a bss in the
|
|
|
|
* @corrupt_data field of &struct ieee80211_bss.
|
|
|
|
*/
|
|
|
|
enum ieee80211_bss_corrupt_data_flags {
|
|
|
|
IEEE80211_BSS_CORRUPT_BEACON = BIT(0),
|
|
|
|
IEEE80211_BSS_CORRUPT_PROBE_RESP = BIT(1)
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* enum ieee80211_valid_data_flags - BSS valid data flags
|
|
|
|
* @IEEE80211_BSS_VALID_WMM: WMM/UAPSD data was gathered from non-corrupt IE
|
|
|
|
* @IEEE80211_BSS_VALID_RATES: Supported rates were gathered from non-corrupt IE
|
|
|
|
* @IEEE80211_BSS_VALID_ERP: ERP flag was gathered from non-corrupt IE
|
|
|
|
*
|
|
|
|
* These are bss flags that are attached to a bss in the
|
|
|
|
* @valid_data field of &struct ieee80211_bss. They show which parts
|
2014-10-30 05:55:58 +00:00
|
|
|
* of the data structure were received as a result of an un-corrupted
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
* beacon/probe response.
|
|
|
|
*/
|
|
|
|
enum ieee80211_bss_valid_data_flags {
|
|
|
|
IEEE80211_BSS_VALID_WMM = BIT(1),
|
|
|
|
IEEE80211_BSS_VALID_RATES = BIT(2),
|
|
|
|
IEEE80211_BSS_VALID_ERP = BIT(3)
|
2007-05-05 18:45:53 +00:00
|
|
|
};
|
|
|
|
|
2016-12-11 04:34:53 +00:00
|
|
|
typedef unsigned __bitwise ieee80211_tx_result;
|
2008-01-31 18:48:20 +00:00
|
|
|
#define TX_CONTINUE ((__force ieee80211_tx_result) 0u)
|
|
|
|
#define TX_DROP ((__force ieee80211_tx_result) 1u)
|
|
|
|
#define TX_QUEUED ((__force ieee80211_tx_result) 2u)
|
|
|
|
|
2008-02-25 15:27:43 +00:00
|
|
|
#define IEEE80211_TX_UNICAST BIT(1)
|
|
|
|
#define IEEE80211_TX_PS_BUFFERED BIT(2)
|
|
|
|
|
|
|
|
struct ieee80211_tx_data {
|
|
|
|
struct sk_buff *skb;
|
2011-11-16 14:28:55 +00:00
|
|
|
struct sk_buff_head skbs;
|
2008-02-25 15:27:43 +00:00
|
|
|
struct ieee80211_local *local;
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
struct sta_info *sta;
|
|
|
|
struct ieee80211_key *key;
|
2013-04-22 14:14:41 +00:00
|
|
|
struct ieee80211_tx_rate rate;
|
2008-02-25 15:27:43 +00:00
|
|
|
|
2008-03-26 22:21:47 +00:00
|
|
|
unsigned int flags;
|
2008-02-25 15:27:43 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2016-12-11 04:34:53 +00:00
|
|
|
typedef unsigned __bitwise ieee80211_rx_result;
|
2008-01-31 18:48:21 +00:00
|
|
|
#define RX_CONTINUE ((__force ieee80211_rx_result) 0u)
|
|
|
|
#define RX_DROP_UNUSABLE ((__force ieee80211_rx_result) 1u)
|
|
|
|
#define RX_DROP_MONITOR ((__force ieee80211_rx_result) 2u)
|
|
|
|
#define RX_QUEUED ((__force ieee80211_rx_result) 3u)
|
2008-01-31 18:48:20 +00:00
|
|
|
|
2010-09-24 10:38:25 +00:00
|
|
|
/**
|
|
|
|
* enum ieee80211_packet_rx_flags - packet RX flags
|
|
|
|
* @IEEE80211_RX_AMSDU: a-MSDU packet
|
|
|
|
* @IEEE80211_RX_MALFORMED_ACTION_FRM: action frame is malformed
|
2010-12-27 22:21:26 +00:00
|
|
|
* @IEEE80211_RX_DEFERRED_RELEASE: frame was subjected to receive reordering
|
2010-09-24 10:38:25 +00:00
|
|
|
*
|
|
|
|
* These are per-frame flags that are attached to a frame in the
|
|
|
|
* @rx_flags field of &struct ieee80211_rx_status.
|
|
|
|
*/
|
|
|
|
enum ieee80211_packet_rx_flags {
|
|
|
|
IEEE80211_RX_AMSDU = BIT(3),
|
|
|
|
IEEE80211_RX_MALFORMED_ACTION_FRM = BIT(4),
|
2010-12-27 22:21:26 +00:00
|
|
|
IEEE80211_RX_DEFERRED_RELEASE = BIT(5),
|
2010-09-24 10:38:25 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* enum ieee80211_rx_flags - RX data flags
|
|
|
|
*
|
|
|
|
* @IEEE80211_RX_CMNTR: received on cooked monitor already
|
2011-11-04 10:18:18 +00:00
|
|
|
* @IEEE80211_RX_BEACON_REPORTED: This frame was already reported
|
|
|
|
* to cfg80211_report_obss_beacon().
|
2010-09-24 10:38:25 +00:00
|
|
|
*
|
|
|
|
* These flags are used across handling multiple interfaces
|
|
|
|
* for a single frame.
|
|
|
|
*/
|
|
|
|
enum ieee80211_rx_flags {
|
|
|
|
IEEE80211_RX_CMNTR = BIT(0),
|
2011-11-04 10:18:18 +00:00
|
|
|
IEEE80211_RX_BEACON_REPORTED = BIT(1),
|
2010-09-24 10:38:25 +00:00
|
|
|
};
|
2008-02-25 15:27:43 +00:00
|
|
|
|
|
|
|
struct ieee80211_rx_data {
|
2015-06-11 14:02:32 +00:00
|
|
|
struct napi_struct *napi;
|
2007-05-05 18:45:53 +00:00
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_local *local;
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
struct sta_info *sta;
|
|
|
|
struct ieee80211_key *key;
|
2008-03-26 22:21:47 +00:00
|
|
|
|
|
|
|
unsigned int flags;
|
2011-07-07 16:45:03 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Index into sequence numbers array, 0..16
|
|
|
|
* since the last (16) is used for non-QoS,
|
|
|
|
* will be 16 on non-QoS frames.
|
|
|
|
*/
|
|
|
|
int seqno_idx;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Index into the security IV/PN arrays, 0..16
|
|
|
|
* since the last (16) is used for CCMP-encrypted
|
|
|
|
* management frames, will be set to 16 on mgmt
|
|
|
|
* frames and 0 on non-QoS frames.
|
|
|
|
*/
|
|
|
|
int security_idx;
|
|
|
|
|
2008-02-25 15:27:43 +00:00
|
|
|
u32 tkip_iv32;
|
|
|
|
u16 tkip_iv16;
|
2007-05-05 18:45:53 +00:00
|
|
|
};
|
|
|
|
|
2014-06-05 12:21:36 +00:00
|
|
|
struct ieee80211_csa_settings {
|
|
|
|
const u16 *counter_offsets_beacon;
|
|
|
|
const u16 *counter_offsets_presp;
|
|
|
|
|
|
|
|
int n_counter_offsets_beacon;
|
|
|
|
int n_counter_offsets_presp;
|
|
|
|
|
|
|
|
u8 count;
|
|
|
|
};
|
|
|
|
|
2007-12-19 01:03:33 +00:00
|
|
|
struct beacon_data {
|
|
|
|
u8 *head, *tail;
|
|
|
|
int head_len, tail_len;
|
2013-12-15 21:14:16 +00:00
|
|
|
struct ieee80211_meshconf_ie *meshconf;
|
2014-06-05 12:21:36 +00:00
|
|
|
u16 csa_counter_offsets[IEEE80211_MAX_CSA_COUNTERS_NUM];
|
|
|
|
u8 csa_current_counter;
|
2012-02-13 14:17:18 +00:00
|
|
|
struct rcu_head rcu_head;
|
2007-12-19 01:03:33 +00:00
|
|
|
};
|
|
|
|
|
2012-08-06 11:26:16 +00:00
|
|
|
struct probe_resp {
|
|
|
|
struct rcu_head rcu_head;
|
|
|
|
int len;
|
2014-06-05 12:21:36 +00:00
|
|
|
u16 csa_counter_offsets[IEEE80211_MAX_CSA_COUNTERS_NUM];
|
2012-08-06 11:26:16 +00:00
|
|
|
u8 data[0];
|
|
|
|
};
|
|
|
|
|
2012-10-10 19:39:50 +00:00
|
|
|
struct ps_data {
|
2007-05-05 18:45:53 +00:00
|
|
|
/* yes, this looks ugly, but guarantees that we can later use
|
|
|
|
* bitmap_empty :)
|
2008-02-20 10:21:35 +00:00
|
|
|
* NB: don't touch this bitmap, use sta_info_{set,clear}_tim_bit */
|
2013-12-19 00:52:17 +00:00
|
|
|
u8 tim[sizeof(unsigned long) * BITS_TO_LONGS(IEEE80211_MAX_AID + 1)]
|
|
|
|
__aligned(__alignof__(unsigned long));
|
2012-10-10 19:39:50 +00:00
|
|
|
struct sk_buff_head bc_buf;
|
2008-03-26 22:21:47 +00:00
|
|
|
atomic_t num_sta_ps; /* number of stations in PS mode */
|
2007-12-19 01:03:33 +00:00
|
|
|
int dtim_count;
|
2011-01-31 18:48:44 +00:00
|
|
|
bool dtim_bc_mc;
|
2007-05-05 18:45:53 +00:00
|
|
|
};
|
|
|
|
|
2012-10-10 19:39:50 +00:00
|
|
|
struct ieee80211_if_ap {
|
|
|
|
struct beacon_data __rcu *beacon;
|
|
|
|
struct probe_resp __rcu *probe_resp;
|
|
|
|
|
2013-07-11 14:09:06 +00:00
|
|
|
/* to be used after channel switch. */
|
|
|
|
struct cfg80211_beacon_data *next_beacon;
|
2014-03-05 12:14:08 +00:00
|
|
|
struct list_head vlans; /* write-protected with RTNL and local->mtx */
|
2012-10-10 19:39:50 +00:00
|
|
|
|
|
|
|
struct ps_data ps;
|
|
|
|
atomic_t num_mcast_sta; /* number of stations receiving multicast */
|
2013-10-01 13:45:43 +00:00
|
|
|
enum ieee80211_smps_mode req_smps, /* requested smps mode */
|
|
|
|
driver_smps_mode; /* smps mode request */
|
|
|
|
|
|
|
|
struct work_struct request_smps_work;
|
2016-11-22 10:52:18 +00:00
|
|
|
bool multicast_to_unicast;
|
2012-10-10 19:39:50 +00:00
|
|
|
};
|
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
struct ieee80211_if_wds {
|
|
|
|
struct sta_info *sta;
|
2008-03-26 22:21:47 +00:00
|
|
|
u8 remote_addr[ETH_ALEN];
|
2007-05-05 18:45:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ieee80211_if_vlan {
|
2014-03-05 12:14:08 +00:00
|
|
|
struct list_head list; /* write-protected with RTNL and local->mtx */
|
2009-11-10 19:10:05 +00:00
|
|
|
|
|
|
|
/* used for all tx if the VLAN is configured to 4-addr mode */
|
2011-05-13 12:15:49 +00:00
|
|
|
struct sta_info __rcu *sta;
|
2016-10-10 17:12:21 +00:00
|
|
|
atomic_t num_mcast_sta; /* number of stations receiving multicast */
|
2007-05-05 18:45:53 +00:00
|
|
|
};
|
|
|
|
|
2008-02-23 14:17:11 +00:00
|
|
|
struct mesh_stats {
|
2009-08-18 17:59:00 +00:00
|
|
|
__u32 fwded_mcast; /* Mesh forwarded multicast frames */
|
|
|
|
__u32 fwded_unicast; /* Mesh forwarded unicast frames */
|
|
|
|
__u32 fwded_frames; /* Mesh total forwarded frames */
|
2008-02-23 14:17:11 +00:00
|
|
|
__u32 dropped_frames_ttl; /* Not transmitted since mesh_ttl == 0*/
|
|
|
|
__u32 dropped_frames_no_route; /* Not transmitted, no route found */
|
2011-09-06 20:05:21 +00:00
|
|
|
__u32 dropped_frames_congestion;/* Not forwarded due to congestion */
|
2008-02-23 14:17:11 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define PREQ_Q_F_START 0x1
|
|
|
|
#define PREQ_Q_F_REFRESH 0x2
|
|
|
|
struct mesh_preq_queue {
|
|
|
|
struct list_head list;
|
|
|
|
u8 dst[ETH_ALEN];
|
|
|
|
u8 flags;
|
|
|
|
};
|
|
|
|
|
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 12:28:42 +00:00
|
|
|
struct ieee80211_roc_work {
|
2009-07-07 01:45:17 +00:00
|
|
|
struct list_head list;
|
2009-12-23 12:15:35 +00:00
|
|
|
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
|
2009-12-23 12:15:34 +00:00
|
|
|
struct ieee80211_channel *chan;
|
2009-12-23 12:15:35 +00: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 12:28:42 +00:00
|
|
|
bool started, abort, hw_begun, notified;
|
2014-05-14 13:34:41 +00:00
|
|
|
bool on_channel;
|
2009-12-23 12:15:34 +00:00
|
|
|
|
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-23 22:53:51 +00:00
|
|
|
unsigned long start_time;
|
2009-12-23 12:15:43 +00: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 12:28:42 +00:00
|
|
|
u32 duration, req_duration;
|
|
|
|
struct sk_buff *frame;
|
2012-10-26 14:13:06 +00:00
|
|
|
u64 cookie, mgmt_tx_cookie;
|
2013-02-12 07:34:13 +00:00
|
|
|
enum ieee80211_roc_type type;
|
2009-07-07 01:45:17 +00:00
|
|
|
};
|
|
|
|
|
2009-02-15 11:44:28 +00:00
|
|
|
/* flags used in struct ieee80211_if_managed.flags */
|
2009-07-01 19:41:17 +00:00
|
|
|
enum ieee80211_sta_flags {
|
2009-07-10 13:29:03 +00:00
|
|
|
IEEE80211_STA_CONNECTION_POLL = BIT(1),
|
|
|
|
IEEE80211_STA_CONTROL_PORT = BIT(2),
|
2012-11-22 13:32:09 +00:00
|
|
|
IEEE80211_STA_DISABLE_HT = BIT(4),
|
2009-07-10 13:29:03 +00:00
|
|
|
IEEE80211_STA_MFP_ENABLED = BIT(6),
|
2010-01-12 08:42:31 +00:00
|
|
|
IEEE80211_STA_UAPSD_ENABLED = BIT(7),
|
2010-02-09 09:20:28 +00:00
|
|
|
IEEE80211_STA_NULLFUNC_ACKED = BIT(8),
|
2010-03-30 06:28:30 +00:00
|
|
|
IEEE80211_STA_RESET_SIGNAL_AVE = BIT(9),
|
2012-03-28 08:58:36 +00:00
|
|
|
IEEE80211_STA_DISABLE_40MHZ = BIT(10),
|
2012-07-24 03:33:10 +00:00
|
|
|
IEEE80211_STA_DISABLE_VHT = BIT(11),
|
2012-11-22 13:11:39 +00:00
|
|
|
IEEE80211_STA_DISABLE_80P80MHZ = BIT(12),
|
|
|
|
IEEE80211_STA_DISABLE_160MHZ = BIT(13),
|
2013-10-15 10:25:07 +00:00
|
|
|
IEEE80211_STA_DISABLE_WMM = BIT(14),
|
2014-09-03 12:25:02 +00:00
|
|
|
IEEE80211_STA_ENABLE_RRM = BIT(15),
|
2009-07-01 19:41:17 +00:00
|
|
|
};
|
|
|
|
|
2012-01-20 12:55:27 +00:00
|
|
|
struct ieee80211_mgd_auth_data {
|
|
|
|
struct cfg80211_bss *bss;
|
|
|
|
unsigned long timeout;
|
|
|
|
int tries;
|
|
|
|
u16 algorithm, expected_transaction;
|
|
|
|
|
|
|
|
u8 key[WLAN_KEY_LEN_WEP104];
|
|
|
|
u8 key_len, key_idx;
|
|
|
|
bool done;
|
2013-02-13 14:39:57 +00:00
|
|
|
bool timeout_started;
|
2012-01-20 12:55:27 +00:00
|
|
|
|
2012-09-30 16:29:40 +00:00
|
|
|
u16 sae_trans, sae_status;
|
|
|
|
size_t data_len;
|
|
|
|
u8 data[];
|
2012-01-20 12:55:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ieee80211_mgd_assoc_data {
|
|
|
|
struct cfg80211_bss *bss;
|
|
|
|
const u8 *supp_rates;
|
|
|
|
|
|
|
|
unsigned long timeout;
|
|
|
|
int tries;
|
|
|
|
|
|
|
|
u16 capability;
|
|
|
|
u8 prev_bssid[ETH_ALEN];
|
|
|
|
u8 ssid[IEEE80211_MAX_SSID_LEN];
|
|
|
|
u8 ssid_len;
|
|
|
|
u8 supp_rates_len;
|
2012-03-08 14:02:05 +00:00
|
|
|
bool wmm, uapsd;
|
2013-05-16 14:34:17 +00:00
|
|
|
bool need_beacon;
|
2012-01-20 12:55:27 +00:00
|
|
|
bool synced;
|
2013-02-13 14:39:57 +00:00
|
|
|
bool timeout_started;
|
2012-01-20 12:55:27 +00:00
|
|
|
|
2012-05-16 21:43:19 +00:00
|
|
|
u8 ap_ht_param;
|
|
|
|
|
2012-12-07 12:06:48 +00:00
|
|
|
struct ieee80211_vht_cap ap_vht_cap;
|
|
|
|
|
2016-10-26 21:42:05 +00:00
|
|
|
u8 fils_nonces[2 * FILS_NONCE_LEN];
|
|
|
|
u8 fils_kek[FILS_MAX_KEK_LEN];
|
|
|
|
size_t fils_kek_len;
|
|
|
|
|
2012-01-20 12:55:27 +00:00
|
|
|
size_t ie_len;
|
|
|
|
u8 ie[];
|
|
|
|
};
|
|
|
|
|
2014-10-07 07:38:50 +00:00
|
|
|
struct ieee80211_sta_tx_tspec {
|
|
|
|
/* timestamp of the first packet in the time slice */
|
|
|
|
unsigned long time_slice_start;
|
|
|
|
|
|
|
|
u32 admitted_time; /* in usecs, unlike over the air */
|
|
|
|
u8 tsid;
|
|
|
|
s8 up; /* signed to be able to invalidate with -1 during teardown */
|
|
|
|
|
|
|
|
/* consumed TX time in microseconds in the time slice */
|
|
|
|
u32 consumed_tx_time;
|
|
|
|
enum {
|
|
|
|
TX_TSPEC_ACTION_NONE = 0,
|
|
|
|
TX_TSPEC_ACTION_DOWNGRADE,
|
|
|
|
TX_TSPEC_ACTION_STOP_DOWNGRADE,
|
|
|
|
} action;
|
|
|
|
bool downgraded;
|
|
|
|
};
|
|
|
|
|
2017-02-15 08:49:26 +00:00
|
|
|
DECLARE_EWMA(beacon_signal, 4, 4)
|
2015-08-28 08:52:54 +00:00
|
|
|
|
2009-02-15 11:44:28 +00:00
|
|
|
struct ieee80211_if_managed {
|
2008-03-26 22:21:47 +00:00
|
|
|
struct timer_list timer;
|
2009-07-10 13:29:03 +00:00
|
|
|
struct timer_list conn_mon_timer;
|
|
|
|
struct timer_list bcn_mon_timer;
|
2009-01-06 03:58:37 +00:00
|
|
|
struct timer_list chswitch_timer;
|
2009-07-10 13:29:03 +00:00
|
|
|
struct work_struct monitor_work;
|
2009-01-06 03:58:37 +00:00
|
|
|
struct work_struct chswitch_work;
|
2010-03-19 05:14:53 +00:00
|
|
|
struct work_struct beacon_connection_loss_work;
|
2012-08-01 20:32:45 +00:00
|
|
|
struct work_struct csa_connection_drop_work;
|
2009-02-15 11:44:28 +00:00
|
|
|
|
2010-11-19 21:55:38 +00:00
|
|
|
unsigned long beacon_timeout;
|
2009-07-10 13:29:03 +00:00
|
|
|
unsigned long probe_timeout;
|
2009-07-31 15:54:12 +00:00
|
|
|
int probe_send_count;
|
2010-12-02 20:01:08 +00:00
|
|
|
bool nullfunc_failed;
|
2013-01-29 12:13:50 +00:00
|
|
|
bool connection_loss;
|
2009-07-10 13:29:03 +00:00
|
|
|
|
2009-12-23 12:15:39 +00:00
|
|
|
struct cfg80211_bss *associated;
|
2012-01-20 12:55:27 +00:00
|
|
|
struct ieee80211_mgd_auth_data *auth_data;
|
|
|
|
struct ieee80211_mgd_assoc_data *assoc_data;
|
2009-02-15 11:44:28 +00:00
|
|
|
|
2016-10-15 11:28:19 +00:00
|
|
|
u8 bssid[ETH_ALEN] __aligned(2);
|
2009-02-15 11:44:28 +00:00
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
u16 aid;
|
|
|
|
|
2009-04-16 11:17:24 +00:00
|
|
|
bool powersave; /* powersave requested for this iface */
|
2011-10-28 09:59:47 +00:00
|
|
|
bool broken_ap; /* AP is broken -- turn off powersave */
|
2013-05-16 14:34:17 +00:00
|
|
|
bool have_beacon;
|
2012-12-10 14:38:14 +00:00
|
|
|
u8 dtim_period;
|
2009-12-01 12:37:02 +00:00
|
|
|
enum ieee80211_smps_mode req_smps, /* requested smps mode */
|
2010-08-05 15:05:55 +00:00
|
|
|
driver_smps_mode; /* smps mode request */
|
|
|
|
|
|
|
|
struct work_struct request_smps_work;
|
2009-04-16 11:17:24 +00:00
|
|
|
|
2007-08-28 21:01:54 +00:00
|
|
|
unsigned int flags;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2014-10-08 06:48:39 +00:00
|
|
|
bool csa_waiting_bcn;
|
2015-03-12 06:53:26 +00:00
|
|
|
bool csa_ignored_same_chan;
|
2014-10-08 06:48:39 +00:00
|
|
|
|
mac80211: Add validity check for beacon_crc value
On association to an AP, after receiving beacons, the beacon_crc value is set.
The beacon_crc value is not reset in disassociation, but the BSS data may be
expired at a later point. When associating again, it's possible that a
beacon for the AP is not received, resulting in the beacon_ies to remain NULL.
After association, further beacons will not update the beacon data, as the
crc value of the beacon has not changed, and the beacon_crc still holds a
value matching the beacon. The beacon_ies will remain forever null.
One of the results of this is that WLAN power save cannot be entered, the STA
will remain foreven in active mode.
Fix this by adding a validation flag for the beacon_crc, which is cleared on
association.
Signed-off-by: Juuso Oikarinen <juuso.oikarinen@nokia.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-10-01 13:02:31 +00:00
|
|
|
bool beacon_crc_valid;
|
mac80211: implement beacon filtering in software
Regardless of whether the hardware implements beacon filtering,
there's no need to process all beacons in software all the time
throughout the stack (mac80211 does a lot, then cfg80211, then
in the future possibly userspace).
This patch implements the "best possible" beacon filtering in
mac80211. "Best possible" means that it can look for changes in
all requested information elements, and distinguish vendor IEs
by their OUI.
In the future, we will add nl80211 API for userspace to request
information elements and vendor IE OUIs to watch -- drivers can
then implement the best they can do while software implements
it fully.
It is unclear whether or not this actually saves CPU time, but
the data is all in the cache already so it should be fairly
cheap. The additional _testing_, however, has great benefit;
Without this, and on hardware that doesn't implement beacon
filtering, wrong assumptions about, for example, scan result
updates could quickly creep into code.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-04-16 11:17:26 +00:00
|
|
|
u32 beacon_crc;
|
|
|
|
|
2013-01-29 14:02:27 +00:00
|
|
|
bool status_acked;
|
|
|
|
bool status_received;
|
|
|
|
__le16 status_fc;
|
|
|
|
|
2009-01-08 11:32:05 +00:00
|
|
|
enum {
|
|
|
|
IEEE80211_MFP_DISABLED,
|
|
|
|
IEEE80211_MFP_OPTIONAL,
|
|
|
|
IEEE80211_MFP_REQUIRED
|
|
|
|
} mfp; /* management frame protection */
|
|
|
|
|
2012-03-14 14:15:03 +00:00
|
|
|
/*
|
|
|
|
* Bitmask of enabled u-apsd queues,
|
|
|
|
* IEEE80211_WMM_IE_STA_QOSINFO_AC_BE & co. Needs a new association
|
|
|
|
* to take effect.
|
|
|
|
*/
|
|
|
|
unsigned int uapsd_queues;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Maximum number of buffered frames AP can deliver during a
|
|
|
|
* service period, IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL or similar.
|
|
|
|
* Needs a new association to take effect.
|
|
|
|
*/
|
|
|
|
unsigned int uapsd_max_sp_len;
|
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
int wmm_last_param_set;
|
2009-11-19 10:55:19 +00:00
|
|
|
|
|
|
|
u8 use_4addr;
|
2010-03-30 06:28:30 +00:00
|
|
|
|
2013-03-21 14:47:56 +00:00
|
|
|
s16 p2p_noa_index;
|
2012-10-29 19:08:01 +00:00
|
|
|
|
2015-08-28 08:52:54 +00:00
|
|
|
struct ewma_beacon_signal ave_beacon_signal;
|
2010-03-30 06:28:30 +00:00
|
|
|
|
2010-08-27 19:22:00 +00:00
|
|
|
/*
|
|
|
|
* Number of Beacon frames used in ave_beacon_signal. This can be used
|
|
|
|
* to avoid generating less reliable cqm events that would be based
|
|
|
|
* only on couple of received frames.
|
|
|
|
*/
|
|
|
|
unsigned int count_beacon_signal;
|
|
|
|
|
2015-10-16 15:18:11 +00:00
|
|
|
/* Number of times beacon loss was invoked. */
|
|
|
|
unsigned int beacon_loss_count;
|
|
|
|
|
2010-03-30 06:28:30 +00:00
|
|
|
/*
|
|
|
|
* Last Beacon frame signal strength average (ave_beacon_signal / 16)
|
|
|
|
* that triggered a cqm event. 0 indicates that no event has been
|
|
|
|
* generated for the current association.
|
|
|
|
*/
|
|
|
|
int last_cqm_event_signal;
|
2011-07-08 15:46:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* State variables for keeping track of RSSI of the AP currently
|
|
|
|
* connected to and informing driver when RSSI has gone
|
|
|
|
* below/above a certain threshold.
|
|
|
|
*/
|
|
|
|
int rssi_min_thold, rssi_max_thold;
|
|
|
|
int last_ave_beacon_signal;
|
2011-11-18 19:32:00 +00:00
|
|
|
|
|
|
|
struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
|
|
|
|
struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */
|
2013-02-21 16:40:19 +00:00
|
|
|
struct ieee80211_vht_cap vht_capa; /* configured VHT overrides */
|
|
|
|
struct ieee80211_vht_cap vht_capa_mask; /* Valid parts of vht_capa */
|
2014-07-17 14:14:25 +00:00
|
|
|
|
2014-11-09 16:50:08 +00:00
|
|
|
/* TDLS support */
|
2014-07-17 14:14:25 +00:00
|
|
|
u8 tdls_peer[ETH_ALEN] __aligned(2);
|
|
|
|
struct delayed_work tdls_peer_del_work;
|
2014-11-09 16:50:08 +00:00
|
|
|
struct sk_buff *orig_teardown_skb; /* The original teardown skb */
|
|
|
|
struct sk_buff *teardown_skb; /* A copy to send through the AP */
|
|
|
|
spinlock_t teardown_lock; /* To lock changing teardown_skb */
|
2014-11-09 16:50:15 +00:00
|
|
|
bool tdls_chan_switch_prohibited;
|
2015-08-15 19:39:46 +00:00
|
|
|
bool tdls_wider_bw_prohibited;
|
2014-10-07 07:38:50 +00:00
|
|
|
|
|
|
|
/* WMM-AC TSPEC support */
|
|
|
|
struct ieee80211_sta_tx_tspec tx_tspec[IEEE80211_NUM_ACS];
|
|
|
|
/* Use a separate work struct so that we can do something here
|
|
|
|
* while the sdata->work is flushing the queues, for example.
|
|
|
|
* otherwise, in scenarios where we hardly get any traffic out
|
|
|
|
* on the BE queue, but there's a lot of VO traffic, we might
|
|
|
|
* get stuck in a downgraded situation and flush takes forever.
|
|
|
|
*/
|
|
|
|
struct delayed_work tx_tspec_wk;
|
2007-05-05 18:45:53 +00:00
|
|
|
};
|
|
|
|
|
2009-02-15 11:44:28 +00:00
|
|
|
struct ieee80211_if_ibss {
|
|
|
|
struct timer_list timer;
|
2013-08-28 11:41:31 +00:00
|
|
|
struct work_struct csa_connection_drop_work;
|
2009-02-15 11:44:28 +00:00
|
|
|
|
2009-04-19 19:25:43 +00:00
|
|
|
unsigned long last_scan_completed;
|
2009-05-17 09:40:42 +00:00
|
|
|
|
2010-06-14 09:55:31 +00:00
|
|
|
u32 basic_rates;
|
|
|
|
|
2009-04-19 19:25:43 +00:00
|
|
|
bool fixed_bssid;
|
|
|
|
bool fixed_channel;
|
cfg80211: rework key operation
This reworks the key operation in cfg80211, and now only
allows, from userspace, configuring keys (via nl80211)
after the connection has been established (in managed
mode), the IBSS been joined (in IBSS mode), at any time
(in AP[_VLAN] modes) or never for all the other modes.
In order to do shared key authentication correctly, it
is now possible to give a WEP key to the AUTH command.
To configure static WEP keys, these are given to the
CONNECT or IBSS_JOIN command directly, for a userspace
SME it is assumed it will configure it properly after
the connection has been established.
Since mac80211 used to check the default key in IBSS
mode to see whether or not the network is protected,
it needs an update in that area, as well as an update
to make use of the WEP key passed to auth() for shared
key authentication.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-08 12:22:54 +00:00
|
|
|
bool privacy;
|
2009-02-15 11:44:28 +00:00
|
|
|
|
2012-01-31 19:25:47 +00:00
|
|
|
bool control_port;
|
2013-10-07 16:41:06 +00:00
|
|
|
bool userspace_handles_dfs;
|
2012-01-31 19:25:47 +00:00
|
|
|
|
2012-03-01 10:23:37 +00:00
|
|
|
u8 bssid[ETH_ALEN] __aligned(2);
|
2009-04-19 19:25:43 +00:00
|
|
|
u8 ssid[IEEE80211_MAX_SSID_LEN];
|
|
|
|
u8 ssid_len, ie_len;
|
|
|
|
u8 *ie;
|
2013-05-16 11:00:36 +00:00
|
|
|
struct cfg80211_chan_def chandef;
|
2009-02-15 11:44:28 +00:00
|
|
|
|
|
|
|
unsigned long ibss_join_req;
|
2009-04-19 19:25:43 +00:00
|
|
|
/* probe response/beacon for IBSS */
|
2013-03-07 19:54:29 +00:00
|
|
|
struct beacon_data __rcu *presp;
|
2009-02-15 11:44:28 +00:00
|
|
|
|
2013-06-28 08:39:59 +00:00
|
|
|
struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
|
|
|
|
struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */
|
|
|
|
|
2011-12-15 10:17:37 +00:00
|
|
|
spinlock_t incomplete_lock;
|
|
|
|
struct list_head incomplete_stations;
|
|
|
|
|
2009-02-15 11:44:28 +00:00
|
|
|
enum {
|
|
|
|
IEEE80211_IBSS_MLME_SEARCH,
|
|
|
|
IEEE80211_IBSS_MLME_JOINED,
|
|
|
|
} state;
|
|
|
|
};
|
|
|
|
|
2014-11-03 09:33:19 +00:00
|
|
|
/**
|
|
|
|
* struct ieee80211_if_ocb - OCB mode state
|
|
|
|
*
|
|
|
|
* @housekeeping_timer: timer for periodic invocation of a housekeeping task
|
|
|
|
* @wrkq_flags: OCB deferred task action
|
|
|
|
* @incomplete_lock: delayed STA insertion lock
|
|
|
|
* @incomplete_stations: list of STAs waiting for delayed insertion
|
|
|
|
* @joined: indication if the interface is connected to an OCB network
|
|
|
|
*/
|
|
|
|
struct ieee80211_if_ocb {
|
|
|
|
struct timer_list housekeeping_timer;
|
|
|
|
unsigned long wrkq_flags;
|
|
|
|
|
|
|
|
spinlock_t incomplete_lock;
|
|
|
|
struct list_head incomplete_stations;
|
|
|
|
|
|
|
|
bool joined;
|
|
|
|
};
|
|
|
|
|
2012-03-31 18:31:32 +00:00
|
|
|
/**
|
|
|
|
* struct ieee80211_mesh_sync_ops - Extensible synchronization framework interface
|
|
|
|
*
|
|
|
|
* these declarations define the interface, which enables
|
|
|
|
* vendor-specific mesh synchronization
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
struct ieee802_11_elems;
|
|
|
|
struct ieee80211_mesh_sync_ops {
|
|
|
|
void (*rx_bcn_presp)(struct ieee80211_sub_if_data *sdata,
|
|
|
|
u16 stype,
|
|
|
|
struct ieee80211_mgmt *mgmt,
|
|
|
|
struct ieee802_11_elems *elems,
|
|
|
|
struct ieee80211_rx_status *rx_status);
|
2013-12-15 21:14:16 +00:00
|
|
|
|
|
|
|
/* should be called with beacon_data under RCU read lock */
|
2016-12-08 01:15:51 +00:00
|
|
|
void (*adjust_tsf)(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct beacon_data *beacon);
|
2012-03-31 18:31:32 +00:00
|
|
|
/* add other framework functions here */
|
|
|
|
};
|
|
|
|
|
2013-10-17 22:55:02 +00:00
|
|
|
struct mesh_csa_settings {
|
|
|
|
struct rcu_head rcu_head;
|
|
|
|
struct cfg80211_csa_settings settings;
|
|
|
|
};
|
|
|
|
|
2008-09-10 22:01:49 +00:00
|
|
|
struct ieee80211_if_mesh {
|
|
|
|
struct timer_list housekeeping_timer;
|
|
|
|
struct timer_list mesh_path_timer;
|
2009-11-09 23:46:56 +00:00
|
|
|
struct timer_list mesh_path_root_timer;
|
2008-09-10 22:01:49 +00:00
|
|
|
|
2009-08-10 19:15:52 +00:00
|
|
|
unsigned long wrkq_flags;
|
2013-06-13 22:54:41 +00:00
|
|
|
unsigned long mbss_changed;
|
2008-09-10 22:01:49 +00:00
|
|
|
|
2017-05-16 09:23:13 +00:00
|
|
|
bool userspace_handles_dfs;
|
|
|
|
|
2008-09-10 22:01:49 +00:00
|
|
|
u8 mesh_id[IEEE80211_MAX_MESH_ID_LEN];
|
|
|
|
size_t mesh_id_len;
|
|
|
|
/* Active Path Selection Protocol Identifier */
|
2009-11-09 23:46:39 +00:00
|
|
|
u8 mesh_pp_id;
|
2008-09-10 22:01:49 +00:00
|
|
|
/* Active Path Selection Metric Identifier */
|
2009-11-09 23:46:39 +00:00
|
|
|
u8 mesh_pm_id;
|
2008-09-10 22:01:49 +00:00
|
|
|
/* Congestion Control Mode Identifier */
|
2009-11-09 23:46:39 +00:00
|
|
|
u8 mesh_cc_id;
|
2009-08-20 16:21:45 +00:00
|
|
|
/* Synchronization Protocol Identifier */
|
2009-11-09 23:46:39 +00:00
|
|
|
u8 mesh_sp_id;
|
2009-08-20 16:21:45 +00:00
|
|
|
/* Authentication Protocol Identifier */
|
2009-11-09 23:46:39 +00:00
|
|
|
u8 mesh_auth_id;
|
2009-11-09 23:46:55 +00:00
|
|
|
/* Local mesh Sequence Number */
|
|
|
|
u32 sn;
|
2008-09-10 22:01:49 +00:00
|
|
|
/* Last used PREQ ID */
|
|
|
|
u32 preq_id;
|
|
|
|
atomic_t mpaths;
|
2009-11-09 23:46:55 +00:00
|
|
|
/* Timestamp of last SN update */
|
|
|
|
unsigned long last_sn_update;
|
2011-11-25 01:15:24 +00:00
|
|
|
/* Time when it's ok to send next PERR */
|
|
|
|
unsigned long next_perr;
|
|
|
|
/* Timestamp of last PREQ sent */
|
2008-09-10 22:01:49 +00:00
|
|
|
unsigned long last_preq;
|
|
|
|
struct mesh_rmc *rmc;
|
|
|
|
spinlock_t mesh_preq_queue_lock;
|
|
|
|
struct mesh_preq_queue preq_queue;
|
|
|
|
int preq_queue_len;
|
|
|
|
struct mesh_stats mshstats;
|
|
|
|
struct mesh_config mshcfg;
|
2012-10-09 20:27:47 +00:00
|
|
|
atomic_t estab_plinks;
|
2008-09-10 22:01:49 +00:00
|
|
|
u32 mesh_seqnum;
|
|
|
|
bool accepting_plinks;
|
2011-08-09 23:45:08 +00:00
|
|
|
int num_gates;
|
2013-02-14 19:20:13 +00:00
|
|
|
struct beacon_data __rcu *beacon;
|
2011-04-07 22:08:27 +00:00
|
|
|
const u8 *ie;
|
|
|
|
u8 ie_len;
|
2011-05-03 23:57:07 +00:00
|
|
|
enum {
|
|
|
|
IEEE80211_MESH_SEC_NONE = 0x0,
|
|
|
|
IEEE80211_MESH_SEC_AUTHED = 0x1,
|
|
|
|
IEEE80211_MESH_SEC_SECURED = 0x2,
|
|
|
|
} security;
|
2013-03-04 21:06:12 +00:00
|
|
|
bool user_mpm;
|
2012-03-31 18:31:32 +00:00
|
|
|
/* Extensible Synchronization Framework */
|
2012-09-30 15:07:19 +00:00
|
|
|
const struct ieee80211_mesh_sync_ops *sync_ops;
|
2012-03-31 18:31:32 +00:00
|
|
|
s64 sync_offset_clockdrift_max;
|
|
|
|
spinlock_t sync_offset_lock;
|
2013-01-30 17:14:08 +00:00
|
|
|
/* mesh power save */
|
|
|
|
enum nl80211_mesh_power_mode nonpeer_pm;
|
|
|
|
int ps_peers_light_sleep;
|
|
|
|
int ps_peers_deep_sleep;
|
|
|
|
struct ps_data ps;
|
2013-10-15 02:08:27 +00:00
|
|
|
/* Channel Switching Support */
|
2013-10-17 22:55:02 +00:00
|
|
|
struct mesh_csa_settings __rcu *csa;
|
2014-01-13 17:42:58 +00:00
|
|
|
enum {
|
|
|
|
IEEE80211_MESH_CSA_ROLE_NONE,
|
|
|
|
IEEE80211_MESH_CSA_ROLE_INIT,
|
|
|
|
IEEE80211_MESH_CSA_ROLE_REPEATER,
|
|
|
|
} csa_role;
|
2013-10-17 22:55:02 +00:00
|
|
|
u8 chsw_ttl;
|
2013-10-15 02:08:27 +00:00
|
|
|
u16 pre_value;
|
2013-12-15 21:14:16 +00:00
|
|
|
|
|
|
|
/* offset from skb->data while building IE */
|
|
|
|
int meshconf_offset;
|
2016-02-29 01:03:56 +00:00
|
|
|
|
2016-03-02 15:09:20 +00:00
|
|
|
struct mesh_table *mesh_paths;
|
|
|
|
struct mesh_table *mpp_paths; /* Store paths for MPP&MAP */
|
2016-02-29 01:03:56 +00:00
|
|
|
int mesh_paths_generation;
|
|
|
|
int mpp_paths_generation;
|
2008-09-10 22:01:49 +00:00
|
|
|
};
|
2008-02-23 14:17:19 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_MAC80211_MESH
|
2008-09-10 22:01:49 +00:00
|
|
|
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \
|
|
|
|
do { (msh)->mshstats.name++; } while (0)
|
2008-02-23 14:17:19 +00:00
|
|
|
#else
|
2008-09-10 22:01:49 +00:00
|
|
|
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \
|
2008-02-23 14:17:19 +00:00
|
|
|
do { } while (0)
|
|
|
|
#endif
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2008-09-10 22:01:54 +00:00
|
|
|
/**
|
|
|
|
* enum ieee80211_sub_if_data_flags - virtual interface flags
|
|
|
|
*
|
|
|
|
* @IEEE80211_SDATA_ALLMULTI: interface wants all multicast packets
|
|
|
|
* @IEEE80211_SDATA_OPERATING_GMODE: operating in G-only mode
|
|
|
|
* @IEEE80211_SDATA_DONT_BRIDGE_PACKETS: bridge packets between
|
|
|
|
* associated stations and deliver multicast frames both
|
|
|
|
* back to wireless media and to the local net stack.
|
2011-07-12 10:30:59 +00:00
|
|
|
* @IEEE80211_SDATA_DISCONNECT_RESUME: Disconnect after resume.
|
2011-11-03 13:41:13 +00:00
|
|
|
* @IEEE80211_SDATA_IN_DRIVER: indicates interface was added to driver
|
2008-09-10 22:01:54 +00:00
|
|
|
*/
|
|
|
|
enum ieee80211_sub_if_data_flags {
|
|
|
|
IEEE80211_SDATA_ALLMULTI = BIT(0),
|
2009-03-21 16:08:43 +00:00
|
|
|
IEEE80211_SDATA_OPERATING_GMODE = BIT(2),
|
|
|
|
IEEE80211_SDATA_DONT_BRIDGE_PACKETS = BIT(3),
|
2011-07-12 10:30:59 +00:00
|
|
|
IEEE80211_SDATA_DISCONNECT_RESUME = BIT(4),
|
2011-11-03 13:41:13 +00:00
|
|
|
IEEE80211_SDATA_IN_DRIVER = BIT(5),
|
2008-09-10 22:01:54 +00:00
|
|
|
};
|
|
|
|
|
2010-08-27 10:35:58 +00:00
|
|
|
/**
|
|
|
|
* enum ieee80211_sdata_state_bits - virtual interface state bits
|
|
|
|
* @SDATA_STATE_RUNNING: virtual interface is up & running; this
|
|
|
|
* mirrors netif_running() but is separate for interface type
|
|
|
|
* change handling while the interface is up
|
2010-08-27 11:45:28 +00:00
|
|
|
* @SDATA_STATE_OFFCHANNEL: This interface is currently in offchannel
|
|
|
|
* mode, so queues are stopped
|
2012-12-14 13:06:28 +00:00
|
|
|
* @SDATA_STATE_OFFCHANNEL_BEACON_STOPPED: Beaconing was stopped due
|
|
|
|
* to offchannel, reset when offchannel returns
|
2010-08-27 10:35:58 +00:00
|
|
|
*/
|
|
|
|
enum ieee80211_sdata_state_bits {
|
|
|
|
SDATA_STATE_RUNNING,
|
2010-08-27 11:45:28 +00:00
|
|
|
SDATA_STATE_OFFCHANNEL,
|
2012-12-14 13:06:28 +00:00
|
|
|
SDATA_STATE_OFFCHANNEL_BEACON_STOPPED,
|
2010-08-27 10:35:58 +00:00
|
|
|
};
|
|
|
|
|
2012-06-26 12:37:16 +00:00
|
|
|
/**
|
|
|
|
* enum ieee80211_chanctx_mode - channel context configuration mode
|
|
|
|
*
|
|
|
|
* @IEEE80211_CHANCTX_SHARED: channel context may be used by
|
|
|
|
* multiple interfaces
|
|
|
|
* @IEEE80211_CHANCTX_EXCLUSIVE: channel context can be used
|
|
|
|
* only by a single interface. This can be used for example for
|
|
|
|
* non-fixed channel IBSS.
|
|
|
|
*/
|
|
|
|
enum ieee80211_chanctx_mode {
|
|
|
|
IEEE80211_CHANCTX_SHARED,
|
|
|
|
IEEE80211_CHANCTX_EXCLUSIVE
|
|
|
|
};
|
|
|
|
|
2014-06-25 10:35:06 +00:00
|
|
|
/**
|
|
|
|
* enum ieee80211_chanctx_replace_state - channel context replacement state
|
|
|
|
*
|
|
|
|
* This is used for channel context in-place reservations that require channel
|
|
|
|
* context switch/swap.
|
|
|
|
*
|
|
|
|
* @IEEE80211_CHANCTX_REPLACE_NONE: no replacement is taking place
|
|
|
|
* @IEEE80211_CHANCTX_WILL_BE_REPLACED: this channel context will be replaced
|
|
|
|
* by a (not yet registered) channel context pointed by %replace_ctx.
|
|
|
|
* @IEEE80211_CHANCTX_REPLACES_OTHER: this (not yet registered) channel context
|
|
|
|
* replaces an existing channel context pointed to by %replace_ctx.
|
|
|
|
*/
|
|
|
|
enum ieee80211_chanctx_replace_state {
|
|
|
|
IEEE80211_CHANCTX_REPLACE_NONE,
|
|
|
|
IEEE80211_CHANCTX_WILL_BE_REPLACED,
|
|
|
|
IEEE80211_CHANCTX_REPLACES_OTHER,
|
|
|
|
};
|
|
|
|
|
2012-06-26 12:37:16 +00:00
|
|
|
struct ieee80211_chanctx {
|
|
|
|
struct list_head list;
|
|
|
|
struct rcu_head rcu_head;
|
|
|
|
|
2014-04-09 13:29:26 +00:00
|
|
|
struct list_head assigned_vifs;
|
2014-04-09 13:29:27 +00:00
|
|
|
struct list_head reserved_vifs;
|
2014-04-09 13:29:26 +00:00
|
|
|
|
2014-06-25 10:35:06 +00:00
|
|
|
enum ieee80211_chanctx_replace_state replace_state;
|
|
|
|
struct ieee80211_chanctx *replace_ctx;
|
|
|
|
|
2012-06-26 12:37:16 +00:00
|
|
|
enum ieee80211_chanctx_mode mode;
|
2012-12-13 16:42:30 +00:00
|
|
|
bool driver_present;
|
2012-06-26 12:37:16 +00:00
|
|
|
|
|
|
|
struct ieee80211_chanctx_conf conf;
|
|
|
|
};
|
|
|
|
|
2013-12-17 07:04:43 +00:00
|
|
|
struct mac80211_qos_map {
|
|
|
|
struct cfg80211_qos_map qos_map;
|
|
|
|
struct rcu_head rcu_head;
|
|
|
|
};
|
|
|
|
|
2015-03-27 20:30:37 +00:00
|
|
|
enum txq_info_flags {
|
|
|
|
IEEE80211_TXQ_STOP,
|
|
|
|
IEEE80211_TXQ_AMPDU,
|
2016-03-03 21:59:00 +00:00
|
|
|
IEEE80211_TXQ_NO_AMSDU,
|
2015-03-27 20:30:37 +00:00
|
|
|
};
|
|
|
|
|
2016-05-19 08:37:49 +00:00
|
|
|
/**
|
|
|
|
* struct txq_info - per tid queue
|
|
|
|
*
|
|
|
|
* @tin: contains packets split into multiple flows
|
|
|
|
* @def_flow: used as a fallback flow when a packet destined to @tin hashes to
|
|
|
|
* a fq_flow which is already owned by a different tin
|
2016-05-19 08:37:51 +00:00
|
|
|
* @def_cvars: codel vars for @def_flow
|
2016-09-22 17:04:20 +00:00
|
|
|
* @frags: used to keep fragments created after dequeue
|
2016-05-19 08:37:49 +00:00
|
|
|
*/
|
2015-03-27 20:30:37 +00:00
|
|
|
struct txq_info {
|
2016-05-19 08:37:49 +00:00
|
|
|
struct fq_tin tin;
|
|
|
|
struct fq_flow def_flow;
|
2016-05-19 08:37:51 +00:00
|
|
|
struct codel_vars def_cvars;
|
2016-09-12 13:55:43 +00:00
|
|
|
struct codel_stats cstats;
|
2016-09-22 17:04:20 +00:00
|
|
|
struct sk_buff_head frags;
|
2015-03-27 20:30:37 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
/* keep last! */
|
|
|
|
struct ieee80211_txq txq;
|
|
|
|
};
|
|
|
|
|
2016-08-29 20:25:15 +00:00
|
|
|
struct ieee80211_if_mntr {
|
|
|
|
u32 flags;
|
2016-08-29 20:25:16 +00:00
|
|
|
u8 mu_follow_addr[ETH_ALEN] __aligned(2);
|
2017-04-13 11:28:18 +00:00
|
|
|
|
|
|
|
struct list_head list;
|
2016-08-29 20:25:15 +00:00
|
|
|
};
|
|
|
|
|
2016-09-20 14:31:19 +00:00
|
|
|
/**
|
|
|
|
* struct ieee80211_if_nan - NAN state
|
|
|
|
*
|
|
|
|
* @conf: current NAN configuration
|
2016-09-20 14:31:20 +00:00
|
|
|
* @func_ids: a bitmap of available instance_id's
|
2016-09-20 14:31:19 +00:00
|
|
|
*/
|
|
|
|
struct ieee80211_if_nan {
|
|
|
|
struct cfg80211_nan_conf conf;
|
2016-09-20 14:31:20 +00:00
|
|
|
|
|
|
|
/* protects function_inst_ids */
|
|
|
|
spinlock_t func_lock;
|
|
|
|
struct idr function_inst_ids;
|
2016-09-20 14:31:19 +00:00
|
|
|
};
|
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
struct ieee80211_sub_if_data {
|
|
|
|
struct list_head list;
|
|
|
|
|
|
|
|
struct wireless_dev wdev;
|
|
|
|
|
2007-08-28 21:01:55 +00:00
|
|
|
/* keys */
|
|
|
|
struct list_head key_list;
|
|
|
|
|
2011-06-28 13:11:37 +00:00
|
|
|
/* count for keys needing tailroom space allocation */
|
|
|
|
int crypto_tx_tailroom_needed_cnt;
|
mac80211: defer tailroom counter manipulation when roaming
During roaming, the crypto_tx_tailroom_needed_cnt counter
will often take values 2,1,0,1,2 because first keys are
removed and then new keys are added. This is inefficient
because during the 0->1 transition, synchronize_net must
be called to avoid packet races, although typically no
packets would be flowing during that time.
To avoid that, defer the decrement (2->1, 1->0) when keys
are removed (by half a second). This means the counter
will really have the values 2,2,2,3,4 ... 2, thus never
reaching 0 and having to do the 0->1 transition.
Note that this patch entirely disregards the drivers for
which this optimisation was done to start with, for them
the key removal itself will be expensive because it has
to synchronize_net() after the counter is incremented to
remove the key from HW crypto. For them the sequence will
look like this: 0,1,0,1,0,1,0,1,0 (*) which is clearly a
lot more inefficient. This could be addressed separately,
during key removal the 0->1->0 sequence isn't necessary.
(*) it starts at 0 because HW crypto is on, then goes to
1 when HW crypto is disabled for a key, then back to
0 because the key is deleted; this happens for both
keys in the example. When new keys are added, it goes
to 1 first because they're added in software; when a
key is moved to hardware it goes back to 0
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2013-02-22 23:59:03 +00:00
|
|
|
int crypto_tx_tailroom_pending_dec;
|
|
|
|
struct delayed_work dec_tailroom_needed_wk;
|
2011-06-28 13:11:37 +00:00
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
struct net_device *dev;
|
|
|
|
struct ieee80211_local *local;
|
|
|
|
|
2007-08-28 21:01:54 +00:00
|
|
|
unsigned int flags;
|
2007-07-27 13:43:24 +00:00
|
|
|
|
2010-08-27 10:35:58 +00:00
|
|
|
unsigned long state;
|
|
|
|
|
2009-11-25 16:46:19 +00:00
|
|
|
char name[IFNAMSIZ];
|
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
/* Fragment table for host-based reassembly */
|
|
|
|
struct ieee80211_fragment_entry fragments[IEEE80211_FRAGMENT_MAX];
|
|
|
|
unsigned int fragment_next;
|
|
|
|
|
2011-11-18 13:20:44 +00:00
|
|
|
/* TID bitmap for NoAck policy */
|
|
|
|
u16 noack_map;
|
|
|
|
|
2012-06-20 12:39:13 +00:00
|
|
|
/* bit field of ACM bits (BIT(802.1D tag)) */
|
|
|
|
u8 wmm_acm;
|
|
|
|
|
2011-05-13 12:15:49 +00:00
|
|
|
struct ieee80211_key __rcu *keys[NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS];
|
|
|
|
struct ieee80211_key __rcu *default_unicast_key;
|
|
|
|
struct ieee80211_key __rcu *default_multicast_key;
|
|
|
|
struct ieee80211_key __rcu *default_mgmt_key;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2008-10-10 11:21:59 +00:00
|
|
|
u16 sequence_number;
|
2010-08-27 11:26:54 +00:00
|
|
|
__be16 control_port_protocol;
|
|
|
|
bool control_port_no_encrypt;
|
2013-03-24 12:23:27 +00:00
|
|
|
int encrypt_headroom;
|
2008-10-10 11:21:59 +00:00
|
|
|
|
2016-05-19 08:37:48 +00:00
|
|
|
atomic_t num_tx_queued;
|
2012-03-28 09:04:25 +00:00
|
|
|
struct ieee80211_tx_queue_params tx_conf[IEEE80211_NUM_ACS];
|
2013-12-17 07:04:43 +00:00
|
|
|
struct mac80211_qos_map __rcu *qos_map;
|
2011-09-25 17:06:54 +00:00
|
|
|
|
2013-07-11 14:09:06 +00:00
|
|
|
struct work_struct csa_finalize_work;
|
2014-04-09 13:10:59 +00:00
|
|
|
bool csa_block_tx; /* write-protected by sdata_lock and local->mtx */
|
2013-11-11 18:34:54 +00:00
|
|
|
struct cfg80211_chan_def csa_chandef;
|
2013-07-11 14:09:06 +00:00
|
|
|
|
2014-04-09 13:29:26 +00:00
|
|
|
struct list_head assigned_chanctx_list; /* protected by chanctx_mtx */
|
2014-04-09 13:29:27 +00:00
|
|
|
struct list_head reserved_chanctx_list; /* protected by chanctx_mtx */
|
2014-04-09 13:29:26 +00:00
|
|
|
|
2013-10-30 11:09:39 +00:00
|
|
|
/* context reservation -- protected with chanctx_mtx */
|
|
|
|
struct ieee80211_chanctx *reserved_chanctx;
|
|
|
|
struct cfg80211_chan_def reserved_chandef;
|
2014-04-09 13:29:25 +00:00
|
|
|
bool reserved_radar_required;
|
2014-06-25 10:35:06 +00:00
|
|
|
bool reserved_ready;
|
2013-10-30 11:09:39 +00:00
|
|
|
|
2012-09-11 12:34:12 +00:00
|
|
|
/* used to reconfigure hardware SM PS */
|
|
|
|
struct work_struct recalc_smps;
|
|
|
|
|
2010-06-10 08:21:31 +00:00
|
|
|
struct work_struct work;
|
2010-06-10 08:21:30 +00:00
|
|
|
struct sk_buff_head skb_queue;
|
|
|
|
|
2012-09-11 12:34:12 +00:00
|
|
|
u8 needed_rx_chains;
|
|
|
|
enum ieee80211_smps_mode smps_mode;
|
|
|
|
|
2012-10-24 08:59:25 +00:00
|
|
|
int user_power_level; /* in dBm */
|
|
|
|
int ap_power_level; /* in dBm */
|
|
|
|
|
2013-02-08 17:16:20 +00:00
|
|
|
bool radar_required;
|
|
|
|
struct delayed_work dfs_cac_timer_work;
|
|
|
|
|
2007-12-28 13:32:58 +00:00
|
|
|
/*
|
mac80211: make master netdev handling sane
Currently, almost every interface type has a 'bss' pointer
pointing to BSS information. This BSS information, however,
is for a _local_ BSS, not for the BSS we joined, so having
it on a STA mode interface makes little sense, but now they
have it pointing to the master device, which is an AP mode
virtual interface. However, except for some bitrate control
data, this pointer is only used in AP/VLAN modes (for power
saving stations.)
Overall, it is not necessary to even have the master netdev
be a valid virtual interface, and it doesn't have to be on
the list of interfaces either.
This patch changes the master netdev to be special, it now
- no longer is on the list of virtual interfaces, which
lets me remove a lot of tests for that
- no longer has sub_if_data attached, since that isn't used
Additionally, this patch changes some vlan/ap mode handling
that is related to these 'bss' pointers described above (but
in the VLAN case they actually make sense because there they
point to the AP they belong to); it also adds some debugging
code to IEEE80211_DEV_TO_SUB_IF to validate it is not called
on the master netdev any more.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-07-09 12:40:34 +00:00
|
|
|
* AP this belongs to: self in AP mode and
|
|
|
|
* corresponding AP in VLAN mode, NULL for
|
|
|
|
* all others (might be needed later in IBSS)
|
2007-12-28 13:32:58 +00:00
|
|
|
*/
|
mac80211: make master netdev handling sane
Currently, almost every interface type has a 'bss' pointer
pointing to BSS information. This BSS information, however,
is for a _local_ BSS, not for the BSS we joined, so having
it on a STA mode interface makes little sense, but now they
have it pointing to the master device, which is an AP mode
virtual interface. However, except for some bitrate control
data, this pointer is only used in AP/VLAN modes (for power
saving stations.)
Overall, it is not necessary to even have the master netdev
be a valid virtual interface, and it doesn't have to be on
the list of interfaces either.
This patch changes the master netdev to be special, it now
- no longer is on the list of virtual interfaces, which
lets me remove a lot of tests for that
- no longer has sub_if_data attached, since that isn't used
Additionally, this patch changes some vlan/ap mode handling
that is related to these 'bss' pointers described above (but
in the VLAN case they actually make sense because there they
point to the AP they belong to); it also adds some debugging
code to IEEE80211_DEV_TO_SUB_IF to validate it is not called
on the master netdev any more.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-07-09 12:40:34 +00:00
|
|
|
struct ieee80211_if_ap *bss;
|
|
|
|
|
2010-01-06 11:09:08 +00:00
|
|
|
/* bitmap of allowed (non-MCS) rate indexes for rate control */
|
2016-04-12 13:56:15 +00:00
|
|
|
u32 rc_rateidx_mask[NUM_NL80211_BANDS];
|
2013-04-16 11:38:42 +00:00
|
|
|
|
2016-04-12 13:56:15 +00:00
|
|
|
bool rc_has_mcs_mask[NUM_NL80211_BANDS];
|
|
|
|
u8 rc_rateidx_mcs_mask[NUM_NL80211_BANDS][IEEE80211_HT_MCS_MASK_LEN];
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2016-04-12 13:56:15 +00:00
|
|
|
bool rc_has_vht_mcs_mask[NUM_NL80211_BANDS];
|
|
|
|
u16 rc_rateidx_vht_mcs_mask[NUM_NL80211_BANDS][NL80211_VHT_NSS_MAX];
|
2015-08-06 21:47:33 +00:00
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
union {
|
|
|
|
struct ieee80211_if_ap ap;
|
|
|
|
struct ieee80211_if_wds wds;
|
|
|
|
struct ieee80211_if_vlan vlan;
|
2009-02-15 11:44:28 +00:00
|
|
|
struct ieee80211_if_managed mgd;
|
|
|
|
struct ieee80211_if_ibss ibss;
|
2008-09-10 22:01:49 +00:00
|
|
|
struct ieee80211_if_mesh mesh;
|
2014-11-03 09:33:19 +00:00
|
|
|
struct ieee80211_if_ocb ocb;
|
2016-08-29 20:25:15 +00:00
|
|
|
struct ieee80211_if_mntr mntr;
|
2016-09-20 14:31:19 +00:00
|
|
|
struct ieee80211_if_nan nan;
|
2007-05-05 18:45:53 +00:00
|
|
|
} u;
|
2007-05-05 18:46:38 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_MAC80211_DEBUGFS
|
2008-08-28 12:12:06 +00:00
|
|
|
struct {
|
2010-09-23 03:29:01 +00:00
|
|
|
struct dentry *subdir_stations;
|
2010-12-09 18:49:02 +00:00
|
|
|
struct dentry *default_unicast_key;
|
|
|
|
struct dentry *default_multicast_key;
|
2009-01-08 11:32:02 +00:00
|
|
|
struct dentry *default_mgmt_key;
|
2009-10-27 11:59:03 +00:00
|
|
|
} debugfs;
|
2007-05-05 18:46:38 +00:00
|
|
|
#endif
|
2012-12-13 16:16:45 +00:00
|
|
|
|
2007-12-19 00:31:26 +00:00
|
|
|
/* must be last, dynamically sized area in this! */
|
|
|
|
struct ieee80211_vif vif;
|
2007-05-05 18:45:53 +00:00
|
|
|
};
|
|
|
|
|
2007-12-19 00:31:26 +00:00
|
|
|
static inline
|
|
|
|
struct ieee80211_sub_if_data *vif_to_sdata(struct ieee80211_vif *p)
|
|
|
|
{
|
|
|
|
return container_of(p, struct ieee80211_sub_if_data, vif);
|
|
|
|
}
|
|
|
|
|
2013-05-10 10:32:47 +00:00
|
|
|
static inline void sdata_lock(struct ieee80211_sub_if_data *sdata)
|
|
|
|
__acquires(&sdata->wdev.mtx)
|
|
|
|
{
|
|
|
|
mutex_lock(&sdata->wdev.mtx);
|
|
|
|
__acquire(&sdata->wdev.mtx);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void sdata_unlock(struct ieee80211_sub_if_data *sdata)
|
|
|
|
__releases(&sdata->wdev.mtx)
|
|
|
|
{
|
|
|
|
mutex_unlock(&sdata->wdev.mtx);
|
|
|
|
__release(&sdata->wdev.mtx);
|
|
|
|
}
|
|
|
|
|
2013-11-21 17:19:50 +00:00
|
|
|
#define sdata_dereference(p, sdata) \
|
|
|
|
rcu_dereference_protected(p, lockdep_is_held(&sdata->wdev.mtx))
|
|
|
|
|
2013-05-10 10:32:47 +00:00
|
|
|
static inline void
|
|
|
|
sdata_assert_lock(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
lockdep_assert_held(&sdata->wdev.mtx);
|
|
|
|
}
|
|
|
|
|
2013-07-08 14:55:51 +00:00
|
|
|
static inline int
|
|
|
|
ieee80211_chandef_get_shift(struct cfg80211_chan_def *chandef)
|
|
|
|
{
|
|
|
|
switch (chandef->width) {
|
|
|
|
case NL80211_CHAN_WIDTH_5:
|
|
|
|
return 2;
|
|
|
|
case NL80211_CHAN_WIDTH_10:
|
|
|
|
return 1;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
ieee80211_vif_get_shift(struct ieee80211_vif *vif)
|
|
|
|
{
|
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
int shift = 0;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
chanctx_conf = rcu_dereference(vif->chanctx_conf);
|
|
|
|
if (chanctx_conf)
|
|
|
|
shift = ieee80211_chandef_get_shift(&chanctx_conf->def);
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return shift;
|
|
|
|
}
|
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
enum {
|
|
|
|
IEEE80211_RX_MSG = 1,
|
|
|
|
IEEE80211_TX_STATUS_MSG = 2,
|
|
|
|
};
|
|
|
|
|
2008-12-18 21:35:20 +00:00
|
|
|
enum queue_stop_reason {
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER,
|
2008-12-18 21:35:27 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_PS,
|
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-11 23:51:53 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_CSA,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
|
2009-03-13 10:43:36 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_SUSPEND,
|
2009-06-07 19:58:37 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
|
2013-02-11 17:21:07 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL,
|
2013-02-13 11:25:28 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_FLUSH,
|
2014-06-11 14:18:24 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_TDLS_TEARDOWN,
|
2014-11-19 11:47:38 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_RESERVE_TID,
|
2021-01-22 16:11:16 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_IFTYPE_CHANGE,
|
2014-06-13 13:30:05 +00:00
|
|
|
|
|
|
|
IEEE80211_QUEUE_STOP_REASONS,
|
2008-12-18 21:35:20 +00:00
|
|
|
};
|
|
|
|
|
2010-12-21 14:02:17 +00:00
|
|
|
#ifdef CONFIG_MAC80211_LEDS
|
2010-11-30 07:58:45 +00:00
|
|
|
struct tpt_led_trigger {
|
|
|
|
char name[32];
|
|
|
|
const struct ieee80211_tpt_blink *blink_table;
|
|
|
|
unsigned int blink_table_len;
|
|
|
|
struct timer_list timer;
|
|
|
|
unsigned long prev_traffic;
|
|
|
|
unsigned long tx_bytes, rx_bytes;
|
2010-11-30 07:59:23 +00:00
|
|
|
unsigned int active, want;
|
|
|
|
bool running;
|
2010-11-30 07:58:45 +00:00
|
|
|
};
|
2010-12-21 14:02:17 +00:00
|
|
|
#endif
|
2010-11-30 07:58:45 +00:00
|
|
|
|
2009-07-23 11:18:01 +00:00
|
|
|
/**
|
|
|
|
* mac80211 scan flags - currently active scan mode
|
|
|
|
*
|
|
|
|
* @SCAN_SW_SCANNING: We're currently in the process of scanning but may as
|
|
|
|
* well be on the operating channel
|
|
|
|
* @SCAN_HW_SCANNING: The hardware is scanning for us, we have no way to
|
|
|
|
* determine if we are on the operating channel or not
|
2012-04-17 17:54:16 +00:00
|
|
|
* @SCAN_ONCHANNEL_SCANNING: Do a software scan on only the current operating
|
|
|
|
* channel. This should not interrupt normal traffic.
|
2010-08-26 11:30:26 +00:00
|
|
|
* @SCAN_COMPLETED: Set for our scan work function when the driver reported
|
|
|
|
* that the scan completed.
|
|
|
|
* @SCAN_ABORTED: Set for our scan work function when the driver reported
|
|
|
|
* a scan complete for an aborted scan.
|
2013-09-16 08:12:07 +00:00
|
|
|
* @SCAN_HW_CANCELLED: Set for our scan work function when the scan is being
|
|
|
|
* cancelled.
|
2009-07-23 11:18:01 +00:00
|
|
|
*/
|
2009-07-23 10:14:04 +00:00
|
|
|
enum {
|
|
|
|
SCAN_SW_SCANNING,
|
2009-07-23 11:18:01 +00:00
|
|
|
SCAN_HW_SCANNING,
|
2012-04-17 17:54:16 +00:00
|
|
|
SCAN_ONCHANNEL_SCANNING,
|
2010-08-26 11:30:26 +00:00
|
|
|
SCAN_COMPLETED,
|
|
|
|
SCAN_ABORTED,
|
2013-09-16 08:12:07 +00:00
|
|
|
SCAN_HW_CANCELLED,
|
2009-07-23 11:18:01 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* enum mac80211_scan_state - scan state machine states
|
|
|
|
*
|
|
|
|
* @SCAN_DECISION: Main entry point to the scan state machine, this state
|
|
|
|
* determines if we should keep on scanning or switch back to the
|
|
|
|
* operating channel
|
|
|
|
* @SCAN_SET_CHANNEL: Set the next channel to be scanned
|
|
|
|
* @SCAN_SEND_PROBE: Send probe requests and wait for probe responses
|
2011-11-08 15:21:21 +00:00
|
|
|
* @SCAN_SUSPEND: Suspend the scan and go back to operating channel to
|
|
|
|
* send out data
|
|
|
|
* @SCAN_RESUME: Resume the scan and scan the next channel
|
2012-10-12 04:03:35 +00:00
|
|
|
* @SCAN_ABORT: Abort the scan and go back to operating channel
|
2009-07-23 11:18:01 +00:00
|
|
|
*/
|
|
|
|
enum mac80211_scan_state {
|
|
|
|
SCAN_DECISION,
|
|
|
|
SCAN_SET_CHANNEL,
|
|
|
|
SCAN_SEND_PROBE,
|
2011-11-08 15:21:21 +00:00
|
|
|
SCAN_SUSPEND,
|
|
|
|
SCAN_RESUME,
|
2012-10-12 04:03:35 +00:00
|
|
|
SCAN_ABORT,
|
2009-07-23 10:14:04 +00:00
|
|
|
};
|
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
struct ieee80211_local {
|
|
|
|
/* embed the driver visible part.
|
|
|
|
* don't cast (use the static inlines below), but we keep
|
|
|
|
* it first anyway so they become a no-op */
|
|
|
|
struct ieee80211_hw hw;
|
|
|
|
|
2016-05-19 08:37:49 +00:00
|
|
|
struct fq fq;
|
2016-05-19 08:37:51 +00:00
|
|
|
struct codel_vars *cvars;
|
|
|
|
struct codel_params cparams;
|
2016-05-19 08:37:49 +00:00
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
const struct ieee80211_ops *ops;
|
|
|
|
|
2009-07-30 00:08:07 +00:00
|
|
|
/*
|
|
|
|
* private workqueue to mac80211. mac80211 makes this accessible
|
|
|
|
* via ieee80211_queue_work()
|
|
|
|
*/
|
|
|
|
struct workqueue_struct *workqueue;
|
|
|
|
|
2009-03-23 16:28:42 +00:00
|
|
|
unsigned long queue_stop_reasons[IEEE80211_MAX_QUEUES];
|
2014-06-13 13:30:05 +00:00
|
|
|
int q_stop_reasons[IEEE80211_MAX_QUEUES][IEEE80211_QUEUE_STOP_REASONS];
|
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-11 23:51:53 +00:00
|
|
|
/* also used to protect ampdu_ac_queue and amdpu_ac_stop_refcnt */
|
2008-12-18 21:35:20 +00:00
|
|
|
spinlock_t queue_stop_reason_lock;
|
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-11 23:51:53 +00:00
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
int open_count;
|
2008-01-31 18:48:27 +00:00
|
|
|
int monitors, cooked_mntrs;
|
2008-01-31 18:48:23 +00:00
|
|
|
/* number of interfaces with corresponding FIF_ flags */
|
2010-10-13 10:06:24 +00:00
|
|
|
int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss, fif_pspoll,
|
|
|
|
fif_probe_req;
|
|
|
|
int probe_req_reg;
|
[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 05:29:23 +00:00
|
|
|
unsigned int filter_flags; /* FIF_* */
|
2009-06-17 15:43:56 +00:00
|
|
|
|
2010-08-27 11:26:52 +00:00
|
|
|
bool wiphy_ciphers_allocated;
|
|
|
|
|
2012-07-26 12:55:08 +00:00
|
|
|
bool use_chanctx;
|
|
|
|
|
2009-06-17 15:43:56 +00:00
|
|
|
/* protects the aggregated multicast list and filter calls */
|
|
|
|
spinlock_t filter_lock;
|
|
|
|
|
2009-08-17 14:16:53 +00:00
|
|
|
/* used for uploading changed mc list */
|
|
|
|
struct work_struct reconfig_filter;
|
|
|
|
|
2009-06-17 15:43:56 +00:00
|
|
|
/* aggregated multicast list */
|
2010-04-01 21:22:57 +00:00
|
|
|
struct netdev_hw_addr_list mc_list;
|
2009-06-17 15:43:56 +00:00
|
|
|
|
2008-02-25 15:27:46 +00:00
|
|
|
bool tim_in_locked_section; /* see ieee80211_beacon_get() */
|
2009-05-17 09:40:42 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* suspended is true if we finished all the suspend _and_ we have
|
|
|
|
* not yet come up from resume. This is to be used by mac80211
|
|
|
|
* to ensure driver sanity during suspend and mac80211's own
|
|
|
|
* sanity. It can eventually be used for WoW as well.
|
|
|
|
*/
|
|
|
|
bool suspended;
|
|
|
|
|
2009-11-19 13:29:39 +00:00
|
|
|
/*
|
|
|
|
* Resuming is true while suspended, but when we're reprogramming the
|
|
|
|
* hardware -- at that time it's allowed to use ieee80211_queue_work()
|
|
|
|
* again even though some other parts of the stack are still suspended
|
|
|
|
* and we still drop received frames to avoid waking the stack.
|
|
|
|
*/
|
|
|
|
bool resuming;
|
|
|
|
|
2009-05-17 09:40:42 +00:00
|
|
|
/*
|
|
|
|
* quiescing is true during the suspend process _only_ to
|
|
|
|
* ease timer cancelling etc.
|
|
|
|
*/
|
|
|
|
bool quiescing;
|
|
|
|
|
2009-08-21 12:44:45 +00:00
|
|
|
/* device is started */
|
|
|
|
bool started;
|
|
|
|
|
2012-06-06 08:25:02 +00:00
|
|
|
/* device is during a HW reconfig */
|
|
|
|
bool in_reconfig;
|
|
|
|
|
2011-05-04 13:37:29 +00:00
|
|
|
/* wowlan is enabled -- don't reconfig on resume */
|
|
|
|
bool wowlan;
|
|
|
|
|
2013-02-08 17:16:20 +00:00
|
|
|
struct work_struct radar_detected_work;
|
|
|
|
|
2012-09-11 12:34:12 +00:00
|
|
|
/* number of RX chains the hardware has */
|
|
|
|
u8 rx_chains;
|
|
|
|
|
2007-07-10 17:32:08 +00:00
|
|
|
int tx_headroom; /* required headroom for hardware/radiotap */
|
2007-05-05 18:45:53 +00:00
|
|
|
|
|
|
|
/* Tasklet and skb queue to process calls from IRQ mode. All frames
|
|
|
|
* added to skb_queue will be processed, but frames in
|
|
|
|
* skb_queue_unreliable may be dropped if the total length of these
|
|
|
|
* queues increases over the limit. */
|
|
|
|
#define IEEE80211_IRQSAFE_QUEUE_LIMIT 128
|
|
|
|
struct tasklet_struct tasklet;
|
|
|
|
struct sk_buff_head skb_queue;
|
|
|
|
struct sk_buff_head skb_queue_unreliable;
|
|
|
|
|
2013-02-04 17:44:44 +00:00
|
|
|
spinlock_t rx_path_lock;
|
2010-12-30 16:25:29 +00:00
|
|
|
|
2008-02-25 15:27:46 +00:00
|
|
|
/* Station data */
|
|
|
|
/*
|
2011-12-15 10:24:20 +00:00
|
|
|
* The mutex only protects the list, hash table and
|
|
|
|
* counter, reads are done with RCU.
|
2008-02-25 15:27:46 +00:00
|
|
|
*/
|
2010-02-03 12:59:58 +00:00
|
|
|
struct mutex sta_mtx;
|
2011-12-15 10:24:20 +00:00
|
|
|
spinlock_t tim_lock;
|
2008-02-25 15:27:46 +00:00
|
|
|
unsigned long num_sta;
|
2011-12-15 10:24:20 +00:00
|
|
|
struct list_head sta_list;
|
2016-09-19 11:00:10 +00:00
|
|
|
struct rhltable sta_hash;
|
2007-05-05 18:45:53 +00:00
|
|
|
struct timer_list sta_cleanup;
|
2009-08-07 14:17:38 +00:00
|
|
|
int sta_generation;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2009-03-23 16:28:37 +00:00
|
|
|
struct sk_buff_head pending[IEEE80211_MAX_QUEUES];
|
2007-05-05 18:45:53 +00:00
|
|
|
struct tasklet_struct tx_pending_tasklet;
|
|
|
|
|
2010-06-10 08:21:41 +00:00
|
|
|
atomic_t agg_queue_stop[IEEE80211_MAX_QUEUES];
|
2009-03-23 16:28:41 +00:00
|
|
|
|
2015-04-22 12:40:58 +00:00
|
|
|
/* number of interfaces with allmulti RX */
|
|
|
|
atomic_t iff_allmultis;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
|
|
|
struct rate_control_ref *rate_ctrl;
|
|
|
|
|
2011-03-25 20:39:19 +00:00
|
|
|
struct crypto_cipher *wep_tx_tfm;
|
|
|
|
struct crypto_cipher *wep_rx_tfm;
|
2007-05-05 18:45:53 +00:00
|
|
|
u32 wep_iv;
|
|
|
|
|
2009-01-23 21:54:03 +00:00
|
|
|
/* see iface.c */
|
2007-09-18 21:29:21 +00:00
|
|
|
struct list_head interfaces;
|
2017-04-13 11:28:18 +00:00
|
|
|
struct list_head mon_list; /* only that are IFF_UP && !cooked */
|
2009-01-23 21:54:03 +00:00
|
|
|
struct mutex iflist_mtx;
|
2007-09-18 21:29:21 +00:00
|
|
|
|
2008-04-11 19:40:35 +00:00
|
|
|
/*
|
2010-06-01 08:19:19 +00:00
|
|
|
* Key mutex, protects sdata's key_list and sta_info's
|
2008-04-11 19:40:35 +00:00
|
|
|
* key pointers (write access, they're RCU.)
|
|
|
|
*/
|
2010-06-01 08:19:19 +00:00
|
|
|
struct mutex key_mtx;
|
2008-04-11 19:40:35 +00:00
|
|
|
|
2010-07-30 14:46:07 +00:00
|
|
|
/* mutex for scan and work locking */
|
|
|
|
struct mutex mtx;
|
2008-04-11 19:40:35 +00:00
|
|
|
|
2008-09-10 22:01:55 +00:00
|
|
|
/* Scanning and BSS list */
|
2009-07-23 10:14:04 +00:00
|
|
|
unsigned long scanning;
|
2009-02-10 20:25:55 +00:00
|
|
|
struct cfg80211_ssid scan_ssid;
|
2009-08-07 15:54:07 +00:00
|
|
|
struct cfg80211_scan_request *int_scan_req;
|
2014-11-19 10:55:49 +00:00
|
|
|
struct cfg80211_scan_request __rcu *scan_req;
|
2014-02-05 13:21:13 +00:00
|
|
|
struct ieee80211_scan_request *hw_scan_req;
|
2013-07-08 14:55:56 +00:00
|
|
|
struct cfg80211_chan_def scan_chandef;
|
2016-04-12 13:56:15 +00:00
|
|
|
enum nl80211_band hw_scan_band;
|
2007-05-05 18:45:53 +00:00
|
|
|
int scan_channel_idx;
|
2009-04-01 09:58:36 +00:00
|
|
|
int scan_ies_len;
|
2012-11-29 11:45:18 +00:00
|
|
|
int hw_scan_ies_bufsize;
|
2016-07-05 12:23:12 +00:00
|
|
|
struct cfg80211_scan_info scan_info;
|
2008-01-24 18:38:38 +00:00
|
|
|
|
2011-05-12 13:28:29 +00:00
|
|
|
struct work_struct sched_scan_stopped_work;
|
2012-07-06 19:55:11 +00:00
|
|
|
struct ieee80211_sub_if_data __rcu *sched_scan_sdata;
|
2014-11-19 10:55:49 +00:00
|
|
|
struct cfg80211_sched_scan_request __rcu *sched_scan_req;
|
2014-06-12 20:24:31 +00:00
|
|
|
u8 scan_addr[ETH_ALEN];
|
2011-05-11 14:09:36 +00:00
|
|
|
|
2010-02-24 13:19:21 +00:00
|
|
|
unsigned long leave_oper_channel_time;
|
2009-07-23 10:14:20 +00:00
|
|
|
enum mac80211_scan_state next_scan_state;
|
2007-05-05 18:45:53 +00:00
|
|
|
struct delayed_work scan_work;
|
2012-07-06 19:39:28 +00:00
|
|
|
struct ieee80211_sub_if_data __rcu *scan_sdata;
|
2012-07-26 15:24:39 +00:00
|
|
|
/* For backward compatibility only -- do not use */
|
2013-03-25 15:26:57 +00:00
|
|
|
struct cfg80211_chan_def _oper_chandef;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2009-12-23 12:15:42 +00:00
|
|
|
/* Temporary remain-on-channel for off-channel operations */
|
|
|
|
struct ieee80211_channel *tmp_channel;
|
|
|
|
|
2012-06-26 12:37:16 +00:00
|
|
|
/* channel contexts */
|
|
|
|
struct list_head chanctx_list;
|
|
|
|
struct mutex chanctx_mtx;
|
|
|
|
|
2015-04-22 18:47:28 +00:00
|
|
|
#ifdef CONFIG_MAC80211_LEDS
|
2015-04-23 10:19:22 +00:00
|
|
|
struct led_trigger tx_led, rx_led, assoc_led, radio_led;
|
|
|
|
struct led_trigger tpt_led;
|
|
|
|
atomic_t tx_led_active, rx_led_active, assoc_led_active;
|
|
|
|
atomic_t radio_led_active, tpt_led_active;
|
2015-04-22 18:47:28 +00:00
|
|
|
struct tpt_led_trigger *tpt_led_trigger;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
|
2007-05-05 18:45:53 +00:00
|
|
|
/* SNMP counters */
|
|
|
|
/* dot11CountersTable */
|
|
|
|
u32 dot11TransmittedFragmentCount;
|
|
|
|
u32 dot11MulticastTransmittedFrameCount;
|
|
|
|
u32 dot11FailedCount;
|
|
|
|
u32 dot11RetryCount;
|
|
|
|
u32 dot11MultipleRetryCount;
|
|
|
|
u32 dot11FrameDuplicateCount;
|
|
|
|
u32 dot11ReceivedFragmentCount;
|
|
|
|
u32 dot11MulticastReceivedFrameCount;
|
|
|
|
u32 dot11TransmittedFrameCount;
|
|
|
|
|
|
|
|
/* TX/RX handler statistics */
|
|
|
|
unsigned int tx_handlers_drop;
|
|
|
|
unsigned int tx_handlers_queued;
|
|
|
|
unsigned int tx_handlers_drop_wep;
|
|
|
|
unsigned int tx_handlers_drop_not_assoc;
|
|
|
|
unsigned int tx_handlers_drop_unauth_port;
|
|
|
|
unsigned int rx_handlers_drop;
|
|
|
|
unsigned int rx_handlers_queued;
|
|
|
|
unsigned int rx_handlers_drop_nullfunc;
|
|
|
|
unsigned int rx_handlers_drop_defrag;
|
|
|
|
unsigned int tx_expand_skb_head;
|
|
|
|
unsigned int tx_expand_skb_head_cloned;
|
2015-04-22 18:25:20 +00:00
|
|
|
unsigned int rx_expand_skb_head_defrag;
|
2007-05-05 18:45:53 +00:00
|
|
|
unsigned int rx_handlers_fragments;
|
|
|
|
unsigned int tx_status_drop;
|
|
|
|
#define I802_DEBUG_INC(c) (c)++
|
|
|
|
#else /* CONFIG_MAC80211_DEBUG_COUNTERS */
|
|
|
|
#define I802_DEBUG_INC(c) do { } while (0)
|
|
|
|
#endif /* CONFIG_MAC80211_DEBUG_COUNTERS */
|
|
|
|
|
|
|
|
|
|
|
|
int total_ps_buffered; /* total number of all buffered unicast and
|
|
|
|
* multicast packets for power saving stations
|
|
|
|
*/
|
2008-12-18 21:35:27 +00:00
|
|
|
|
2009-02-10 15:09:31 +00:00
|
|
|
bool pspolling;
|
2009-12-23 12:15:40 +00:00
|
|
|
bool offchannel_ps_enabled;
|
2009-04-16 11:17:24 +00:00
|
|
|
/*
|
|
|
|
* PS can only be enabled when we have exactly one managed
|
|
|
|
* interface (and monitors) in PS, this then points there.
|
|
|
|
*/
|
|
|
|
struct ieee80211_sub_if_data *ps_sdata;
|
2008-12-18 21:35:27 +00:00
|
|
|
struct work_struct dynamic_ps_enable_work;
|
|
|
|
struct work_struct dynamic_ps_disable_work;
|
|
|
|
struct timer_list dynamic_ps_timer;
|
2010-05-27 12:32:13 +00:00
|
|
|
struct notifier_block ifa_notifier;
|
2013-01-14 14:14:34 +00:00
|
|
|
struct notifier_block ifa6_notifier;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2010-06-09 06:51:52 +00:00
|
|
|
/*
|
|
|
|
* The dynamic ps timeout configured from user space via WEXT -
|
|
|
|
* this will override whatever chosen by mac80211 internally.
|
|
|
|
*/
|
|
|
|
int dynamic_ps_forced_timeout;
|
|
|
|
|
2012-10-24 08:59:25 +00:00
|
|
|
int user_power_level; /* in dBm, for all interfaces */
|
2009-01-06 22:23:56 +00:00
|
|
|
|
2009-12-01 12:37:02 +00:00
|
|
|
enum ieee80211_smps_mode smps_mode;
|
|
|
|
|
2009-04-14 08:09:24 +00:00
|
|
|
struct work_struct restart_work;
|
|
|
|
|
2007-05-05 18:46:38 +00:00
|
|
|
#ifdef CONFIG_MAC80211_DEBUGFS
|
|
|
|
struct local_debugfsdentries {
|
2008-09-18 16:14:18 +00:00
|
|
|
struct dentry *rcdir;
|
2007-05-05 18:46:38 +00:00
|
|
|
struct dentry *keys;
|
|
|
|
} debugfs;
|
|
|
|
#endif
|
2010-07-29 20:14:13 +00: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 12:28:42 +00:00
|
|
|
/*
|
|
|
|
* Remain-on-channel support
|
|
|
|
*/
|
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-23 22:53:51 +00:00
|
|
|
struct delayed_work roc_work;
|
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 12:28:42 +00:00
|
|
|
struct list_head roc_list;
|
2010-12-18 16:20:47 +00:00
|
|
|
struct work_struct hw_roc_start, hw_roc_done;
|
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 12:28:42 +00:00
|
|
|
unsigned long hw_roc_start_time;
|
2012-10-26 14:13:06 +00:00
|
|
|
u64 roc_cookie_counter;
|
2010-12-18 16:20:47 +00:00
|
|
|
|
2011-11-06 13:13:34 +00:00
|
|
|
struct idr ack_status_frames;
|
|
|
|
spinlock_t ack_status_lock;
|
|
|
|
|
2012-06-18 18:07:15 +00:00
|
|
|
struct ieee80211_sub_if_data __rcu *p2p_sdata;
|
|
|
|
|
2012-04-03 12:35:57 +00:00
|
|
|
/* virtual monitor interface */
|
|
|
|
struct ieee80211_sub_if_data __rcu *monitor_sdata;
|
2012-11-09 10:39:59 +00:00
|
|
|
struct cfg80211_chan_def monitor_chandef;
|
2014-10-08 06:48:36 +00:00
|
|
|
|
|
|
|
/* extended capabilities provided by mac80211 */
|
|
|
|
u8 ext_capa[8];
|
2015-07-08 12:41:45 +00:00
|
|
|
|
|
|
|
/* TDLS channel switch */
|
|
|
|
struct work_struct tdls_chsw_work;
|
|
|
|
struct sk_buff_head skb_queue_tdls_chsw;
|
2007-05-05 18:45:53 +00:00
|
|
|
};
|
|
|
|
|
mac80211: make master netdev handling sane
Currently, almost every interface type has a 'bss' pointer
pointing to BSS information. This BSS information, however,
is for a _local_ BSS, not for the BSS we joined, so having
it on a STA mode interface makes little sense, but now they
have it pointing to the master device, which is an AP mode
virtual interface. However, except for some bitrate control
data, this pointer is only used in AP/VLAN modes (for power
saving stations.)
Overall, it is not necessary to even have the master netdev
be a valid virtual interface, and it doesn't have to be on
the list of interfaces either.
This patch changes the master netdev to be special, it now
- no longer is on the list of virtual interfaces, which
lets me remove a lot of tests for that
- no longer has sub_if_data attached, since that isn't used
Additionally, this patch changes some vlan/ap mode handling
that is related to these 'bss' pointers described above (but
in the VLAN case they actually make sense because there they
point to the AP they belong to); it also adds some debugging
code to IEEE80211_DEV_TO_SUB_IF to validate it is not called
on the master netdev any more.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-07-09 12:40:34 +00:00
|
|
|
static inline struct ieee80211_sub_if_data *
|
|
|
|
IEEE80211_DEV_TO_SUB_IF(struct net_device *dev)
|
|
|
|
{
|
|
|
|
return netdev_priv(dev);
|
|
|
|
}
|
|
|
|
|
2012-06-15 13:30:18 +00:00
|
|
|
static inline struct ieee80211_sub_if_data *
|
|
|
|
IEEE80211_WDEV_TO_SUB_IF(struct wireless_dev *wdev)
|
|
|
|
{
|
|
|
|
return container_of(wdev, struct ieee80211_sub_if_data, wdev);
|
|
|
|
}
|
|
|
|
|
2017-04-27 07:15:38 +00:00
|
|
|
static inline struct ieee80211_supported_band *
|
|
|
|
ieee80211_get_sband(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
enum nl80211_band band;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
|
|
|
|
|
2019-06-14 11:01:52 +00:00
|
|
|
if (WARN_ON_ONCE(!chanctx_conf)) {
|
2017-04-27 07:15:38 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
band = chanctx_conf->def.chan->band;
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return local->hw.wiphy->bands[band];
|
|
|
|
}
|
|
|
|
|
2013-10-15 02:08:29 +00:00
|
|
|
/* this struct holds the value parsing from channel switch IE */
|
|
|
|
struct ieee80211_csa_ie {
|
|
|
|
struct cfg80211_chan_def chandef;
|
|
|
|
u8 mode;
|
|
|
|
u8 count;
|
|
|
|
u8 ttl;
|
2013-11-08 07:09:43 +00:00
|
|
|
u16 pre_value;
|
2017-05-16 09:23:10 +00:00
|
|
|
u16 reason_code;
|
2013-10-15 02:08:29 +00:00
|
|
|
};
|
|
|
|
|
2011-11-18 15:54:50 +00:00
|
|
|
/* Parsed Information Elements */
|
|
|
|
struct ieee802_11_elems {
|
2013-02-12 15:43:19 +00:00
|
|
|
const u8 *ie_start;
|
2011-11-18 15:54:50 +00:00
|
|
|
size_t total_len;
|
|
|
|
|
|
|
|
/* pointers to IEs */
|
2014-11-09 16:50:18 +00:00
|
|
|
const struct ieee80211_tdls_lnkie *lnk_id;
|
|
|
|
const struct ieee80211_ch_switch_timing *ch_sw_timing;
|
2014-11-09 16:50:15 +00:00
|
|
|
const u8 *ext_capab;
|
2013-02-12 15:43:19 +00:00
|
|
|
const u8 *ssid;
|
|
|
|
const u8 *supp_rates;
|
|
|
|
const u8 *ds_params;
|
|
|
|
const struct ieee80211_tim_ie *tim;
|
|
|
|
const u8 *challenge;
|
|
|
|
const u8 *rsn;
|
|
|
|
const u8 *erp_info;
|
|
|
|
const u8 *ext_supp_rates;
|
|
|
|
const u8 *wmm_info;
|
|
|
|
const u8 *wmm_param;
|
|
|
|
const struct ieee80211_ht_cap *ht_cap_elem;
|
|
|
|
const struct ieee80211_ht_operation *ht_operation;
|
|
|
|
const struct ieee80211_vht_cap *vht_cap_elem;
|
|
|
|
const struct ieee80211_vht_operation *vht_operation;
|
|
|
|
const struct ieee80211_meshconf_ie *mesh_config;
|
|
|
|
const u8 *mesh_id;
|
|
|
|
const u8 *peering;
|
|
|
|
const __le16 *awake_window;
|
|
|
|
const u8 *preq;
|
|
|
|
const u8 *prep;
|
|
|
|
const u8 *perr;
|
|
|
|
const struct ieee80211_rann_ie *rann;
|
|
|
|
const struct ieee80211_channel_sw_ie *ch_switch_ie;
|
2013-03-26 13:13:58 +00:00
|
|
|
const struct ieee80211_ext_chansw_ie *ext_chansw_ie;
|
2013-03-26 13:54:16 +00:00
|
|
|
const struct ieee80211_wide_bw_chansw_ie *wide_bw_chansw_ie;
|
2013-02-12 15:43:19 +00:00
|
|
|
const u8 *country_elem;
|
|
|
|
const u8 *pwr_constr_elem;
|
mac80211: support DTPC IE (from Cisco Client eXtensions)
Linux already supports 802.11h, where the access point can tell the
client to reduce its transmission power. However, 802.11h is only
defined for 5 GHz, where the need for this is much smaller than on
2.4 GHz.
Cisco has their own solution, called DTPC (Dynamic Transmit Power
Control). Cisco APs on a controller sometimes but not always send
802.11h; they always send DTPC, even on 2.4 GHz. This patch adds support
for parsing and honoring the DTPC IE in addition to the 802.11h
element (they do not always contain the same limits, so both must
be honored); the format is not documented, but very simple.
Tested (on top of wireless.git and on 3.16.1) against a Cisco Aironet
1142 joined to a Cisco 2504 WLC, by setting various transmit power
levels for the given access points and observing the results.
The Wireshark 802.11 dissector agrees with the interpretation of the
element, except for negative numbers, which seem to never happen
anyway.
Signed-off-by: Steinar H. Gunderson <sgunderson@bigfoot.com>
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
2014-09-03 13:48:37 +00:00
|
|
|
const u8 *cisco_dtpc_elem;
|
2013-03-27 13:38:07 +00:00
|
|
|
const struct ieee80211_timeout_interval_ie *timeout_int;
|
2013-02-12 15:43:19 +00:00
|
|
|
const u8 *opmode_notif;
|
2013-03-25 17:29:27 +00:00
|
|
|
const struct ieee80211_sec_chan_offs_ie *sec_chan_offs;
|
2018-01-26 22:02:37 +00:00
|
|
|
struct ieee80211_mesh_chansw_params_ie *mesh_chansw_params_ie;
|
2017-04-26 07:58:47 +00:00
|
|
|
const struct ieee80211_bss_max_idle_period_ie *max_idle_period_ie;
|
2011-11-18 15:54:50 +00:00
|
|
|
|
|
|
|
/* length of them, respectively */
|
2014-11-09 16:50:15 +00:00
|
|
|
u8 ext_capab_len;
|
2011-11-18 15:54:50 +00:00
|
|
|
u8 ssid_len;
|
|
|
|
u8 supp_rates_len;
|
|
|
|
u8 tim_len;
|
|
|
|
u8 challenge_len;
|
|
|
|
u8 rsn_len;
|
|
|
|
u8 ext_supp_rates_len;
|
|
|
|
u8 wmm_info_len;
|
|
|
|
u8 wmm_param_len;
|
|
|
|
u8 mesh_id_len;
|
|
|
|
u8 peering_len;
|
|
|
|
u8 preq_len;
|
|
|
|
u8 prep_len;
|
|
|
|
u8 perr_len;
|
|
|
|
u8 country_elem_len;
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
|
|
|
|
/* whether a parse error occurred while retrieving these elements */
|
|
|
|
bool parse_error;
|
2011-11-18 15:54:50 +00:00
|
|
|
};
|
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
static inline struct ieee80211_local *hw_to_local(
|
|
|
|
struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
return container_of(hw, struct ieee80211_local, hw);
|
|
|
|
}
|
|
|
|
|
2015-03-27 20:30:37 +00:00
|
|
|
static inline struct txq_info *to_txq_info(struct ieee80211_txq *txq)
|
|
|
|
{
|
|
|
|
return container_of(txq, struct txq_info, txq);
|
|
|
|
}
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2016-09-22 17:04:20 +00:00
|
|
|
static inline bool txq_has_queue(struct ieee80211_txq *txq)
|
|
|
|
{
|
|
|
|
struct txq_info *txqi = to_txq_info(txq);
|
|
|
|
|
|
|
|
return !(skb_queue_empty(&txqi->frags) && !txqi->tin.backlog_packets);
|
|
|
|
}
|
|
|
|
|
2007-07-27 13:43:22 +00:00
|
|
|
static inline int ieee80211_bssid_match(const u8 *raddr, const u8 *addr)
|
|
|
|
{
|
mac80211: Convert compare_ether_addr to ether_addr_equal
Use the new bool function ether_addr_equal to add
some clarity and reduce the likelihood for misuse
of compare_ether_addr for sorting.
Done via cocci script:
$ cat compare_ether_addr.cocci
@@
expression a,b;
@@
- !compare_ether_addr(a, b)
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- compare_ether_addr(a, b)
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- !ether_addr_equal(a, b) == 0
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- !ether_addr_equal(a, b) != 0
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- ether_addr_equal(a, b) == 0
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- ether_addr_equal(a, b) != 0
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- !!ether_addr_equal(a, b)
+ ether_addr_equal(a, b)
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-05-08 18:56:52 +00:00
|
|
|
return ether_addr_equal(raddr, addr) ||
|
2007-07-27 13:43:22 +00:00
|
|
|
is_broadcast_ether_addr(raddr);
|
|
|
|
}
|
|
|
|
|
2012-11-13 18:46:27 +00:00
|
|
|
static inline bool
|
|
|
|
ieee80211_have_rx_timestamp(struct ieee80211_rx_status *status)
|
|
|
|
{
|
|
|
|
WARN_ON_ONCE(status->flag & RX_FLAG_MACTIME_START &&
|
|
|
|
status->flag & RX_FLAG_MACTIME_END);
|
2016-01-25 13:46:34 +00:00
|
|
|
if (status->flag & (RX_FLAG_MACTIME_START | RX_FLAG_MACTIME_END))
|
|
|
|
return true;
|
2017-04-26 10:14:59 +00:00
|
|
|
/* can't handle non-legacy preamble yet */
|
2016-01-25 13:46:34 +00:00
|
|
|
if (status->flag & RX_FLAG_MACTIME_PLCP_START &&
|
2017-06-12 07:44:58 +00:00
|
|
|
status->encoding == RX_ENC_LEGACY)
|
2016-01-25 13:46:34 +00:00
|
|
|
return true;
|
|
|
|
return false;
|
2012-11-13 18:46:27 +00:00
|
|
|
}
|
2007-07-27 13:43:22 +00:00
|
|
|
|
2016-10-10 17:12:21 +00:00
|
|
|
void ieee80211_vif_inc_num_mcast(struct ieee80211_sub_if_data *sdata);
|
|
|
|
void ieee80211_vif_dec_num_mcast(struct ieee80211_sub_if_data *sdata);
|
|
|
|
|
|
|
|
/* This function returns the number of multicast stations connected to this
|
|
|
|
* interface. It returns -1 if that number is not tracked, that is for netdevs
|
|
|
|
* not in AP or AP_VLAN mode or when using 4addr.
|
|
|
|
*/
|
|
|
|
static inline int
|
|
|
|
ieee80211_vif_get_num_mcast_if(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP)
|
|
|
|
return atomic_read(&sdata->u.ap.num_mcast_sta);
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN && !sdata->u.vlan.sta)
|
|
|
|
return atomic_read(&sdata->u.vlan.num_mcast_sta);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-11-13 18:46:27 +00:00
|
|
|
u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_rx_status *status,
|
|
|
|
unsigned int mpdu_len,
|
|
|
|
unsigned int mpdu_offset);
|
2008-10-09 10:18:51 +00:00
|
|
|
int ieee80211_hw_config(struct ieee80211_local *local, u32 changed);
|
2008-02-25 15:27:43 +00:00
|
|
|
void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx);
|
2008-09-10 22:01:52 +00:00
|
|
|
void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
|
|
|
|
u32 changed);
|
2008-09-10 22:01:59 +00:00
|
|
|
void ieee80211_configure_filter(struct ieee80211_local *local);
|
2009-02-15 11:44:28 +00:00
|
|
|
u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata);
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2015-11-23 16:18:35 +00:00
|
|
|
u64 ieee80211_mgmt_tx_cookie(struct ieee80211_local *local);
|
2015-11-24 13:25:49 +00:00
|
|
|
int ieee80211_attach_ack_skb(struct ieee80211_local *local, struct sk_buff *skb,
|
|
|
|
u64 *cookie, gfp_t gfp);
|
2015-11-23 16:18:35 +00:00
|
|
|
|
2016-03-31 17:02:10 +00:00
|
|
|
void ieee80211_check_fast_rx(struct sta_info *sta);
|
|
|
|
void __ieee80211_check_fast_rx_iface(struct ieee80211_sub_if_data *sdata);
|
|
|
|
void ieee80211_check_fast_rx_iface(struct ieee80211_sub_if_data *sdata);
|
|
|
|
void ieee80211_clear_fast_rx(struct sta_info *sta);
|
|
|
|
|
2009-02-15 11:44:28 +00:00
|
|
|
/* STA code */
|
2008-09-10 22:01:52 +00:00
|
|
|
void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata);
|
2009-07-07 01:45:17 +00:00
|
|
|
int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_auth_request *req);
|
|
|
|
int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_assoc_request *req);
|
|
|
|
int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
|
2012-02-24 12:50:51 +00:00
|
|
|
struct cfg80211_deauth_request *req);
|
2009-07-07 01:45:17 +00:00
|
|
|
int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
|
2012-02-24 12:50:51 +00:00
|
|
|
struct cfg80211_disassoc_request *req);
|
2009-02-10 15:09:31 +00:00
|
|
|
void ieee80211_send_pspoll(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata);
|
2015-10-14 16:02:43 +00:00
|
|
|
void ieee80211_recalc_ps(struct ieee80211_local *local);
|
2012-07-27 09:33:22 +00:00
|
|
|
void ieee80211_recalc_ps_vif(struct ieee80211_sub_if_data *sdata);
|
2010-05-27 12:32:13 +00:00
|
|
|
int ieee80211_set_arp_filter(struct ieee80211_sub_if_data *sdata);
|
2010-06-10 08:21:32 +00:00
|
|
|
void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata);
|
|
|
|
void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb);
|
2010-09-16 19:12:32 +00:00
|
|
|
void ieee80211_sta_reset_beacon_monitor(struct ieee80211_sub_if_data *sdata);
|
2010-09-16 19:12:29 +00:00
|
|
|
void ieee80211_sta_reset_conn_monitor(struct ieee80211_sub_if_data *sdata);
|
2012-04-23 11:45:15 +00:00
|
|
|
void ieee80211_mgd_stop(struct ieee80211_sub_if_data *sdata);
|
2013-01-29 14:02:27 +00:00
|
|
|
void ieee80211_mgd_conn_tx_status(struct ieee80211_sub_if_data *sdata,
|
|
|
|
__le16 fc, bool acked);
|
2014-03-19 08:55:55 +00:00
|
|
|
void ieee80211_mgd_quiesce(struct ieee80211_sub_if_data *sdata);
|
2013-04-29 12:57:44 +00:00
|
|
|
void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata);
|
2014-10-07 07:38:50 +00:00
|
|
|
void ieee80211_sta_handle_tspec_ac_params(struct ieee80211_sub_if_data *sdata);
|
2008-09-10 22:01:52 +00:00
|
|
|
|
2009-02-15 11:44:28 +00:00
|
|
|
/* IBSS code */
|
|
|
|
void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local);
|
|
|
|
void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata);
|
2011-12-15 10:17:37 +00:00
|
|
|
void ieee80211_ibss_rx_no_sta(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *bssid, const u8 *addr, u32 supp_rates);
|
2009-04-19 19:25:43 +00:00
|
|
|
int ieee80211_ibss_join(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_ibss_params *params);
|
|
|
|
int ieee80211_ibss_leave(struct ieee80211_sub_if_data *sdata);
|
2010-06-10 08:21:32 +00:00
|
|
|
void ieee80211_ibss_work(struct ieee80211_sub_if_data *sdata);
|
|
|
|
void ieee80211_ibss_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb);
|
2013-08-28 11:41:31 +00:00
|
|
|
int ieee80211_ibss_csa_beacon(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_csa_settings *csa_settings);
|
|
|
|
int ieee80211_ibss_finish_csa(struct ieee80211_sub_if_data *sdata);
|
|
|
|
void ieee80211_ibss_stop(struct ieee80211_sub_if_data *sdata);
|
2010-06-10 08:21:32 +00:00
|
|
|
|
2014-11-03 09:33:19 +00:00
|
|
|
/* OCB code */
|
|
|
|
void ieee80211_ocb_work(struct ieee80211_sub_if_data *sdata);
|
|
|
|
void ieee80211_ocb_rx_no_sta(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *bssid, const u8 *addr, u32 supp_rates);
|
|
|
|
void ieee80211_ocb_setup_sdata(struct ieee80211_sub_if_data *sdata);
|
|
|
|
int ieee80211_ocb_join(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ocb_setup *setup);
|
|
|
|
int ieee80211_ocb_leave(struct ieee80211_sub_if_data *sdata);
|
|
|
|
|
2010-06-10 08:21:32 +00:00
|
|
|
/* mesh code */
|
|
|
|
void ieee80211_mesh_work(struct ieee80211_sub_if_data *sdata);
|
|
|
|
void ieee80211_mesh_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb);
|
2013-10-17 22:55:02 +00:00
|
|
|
int ieee80211_mesh_csa_beacon(struct ieee80211_sub_if_data *sdata,
|
mac80211: only set CSA beacon when at least one beacon must be transmitted
A beacon should never have a Channel Switch Announcement information
element with a count of 0, because a count of 1 means switch just
before the next beacon. So, if a count of 0 was valid in a beacon, it
would have been transmitted in the next channel already, which is
useless. A CSA count equal to zero is only meaningful in action
frames or probe_responses.
Fix the ieee80211_csa_is_complete() and ieee80211_update_csa()
functions accordingly.
With a CSA count of 0, we won't transmit any CSA beacons, because the
switch will happen before the next TBTT. To avoid extra work and
potential confusion in the drivers, complete the CSA immediately,
instead of waiting for the driver to call ieee80211_csa_finish().
To keep things simpler, we also switch immediately when the CSA count
is 1, while in theory we should delay the switch until just before the
next TBTT.
Additionally, move the ieee80211_csa_finish() function to cfg.c,
where it makes more sense.
Tested-by: Simon Wunderlich <sw@simonwunderlich.de>
Acked-by: Simon Wunderlich <sw@simonwunderlich.de>
Signed-off-by: Luciano Coelho <luciano.coelho@intel.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2014-01-13 17:43:00 +00:00
|
|
|
struct cfg80211_csa_settings *csa_settings);
|
2013-10-17 22:55:02 +00:00
|
|
|
int ieee80211_mesh_finish_csa(struct ieee80211_sub_if_data *sdata);
|
2009-02-15 11:44:28 +00:00
|
|
|
|
2008-09-10 22:01:52 +00:00
|
|
|
/* scan/BSS handling */
|
2009-02-15 11:44:28 +00:00
|
|
|
void ieee80211_scan_work(struct work_struct *work);
|
2012-12-11 09:48:23 +00:00
|
|
|
int ieee80211_request_ibss_scan(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *ssid, u8 ssid_len,
|
2015-03-20 05:37:00 +00:00
|
|
|
struct ieee80211_channel **channels,
|
|
|
|
unsigned int n_channels,
|
2013-07-08 14:55:56 +00:00
|
|
|
enum nl80211_bss_scan_width scan_width);
|
2008-09-10 22:01:55 +00:00
|
|
|
int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
|
2009-02-10 20:25:55 +00:00
|
|
|
struct cfg80211_scan_request *req);
|
2009-05-17 09:40:42 +00:00
|
|
|
void ieee80211_scan_cancel(struct ieee80211_local *local);
|
2012-03-28 14:01:19 +00:00
|
|
|
void ieee80211_run_deferred_scan(struct ieee80211_local *local);
|
2012-07-06 20:19:27 +00:00
|
|
|
void ieee80211_scan_rx(struct ieee80211_local *local, struct sk_buff *skb);
|
2008-09-10 22:01:52 +00:00
|
|
|
|
2008-09-08 15:44:25 +00:00
|
|
|
void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local);
|
2008-09-10 22:01:55 +00:00
|
|
|
struct ieee80211_bss *
|
2008-09-08 15:44:26 +00:00
|
|
|
ieee80211_bss_info_update(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_rx_status *rx_status,
|
|
|
|
struct ieee80211_mgmt *mgmt,
|
|
|
|
size_t len,
|
|
|
|
struct ieee802_11_elems *elems,
|
2012-12-10 14:19:13 +00:00
|
|
|
struct ieee80211_channel *channel);
|
2008-09-08 15:44:26 +00:00
|
|
|
void ieee80211_rx_bss_put(struct ieee80211_local *local,
|
2008-09-10 22:01:55 +00:00
|
|
|
struct ieee80211_bss *bss);
|
2008-02-23 14:17:11 +00:00
|
|
|
|
2011-05-11 14:09:36 +00:00
|
|
|
/* scheduled scan handling */
|
2013-12-08 19:48:57 +00:00
|
|
|
int
|
|
|
|
__ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_sched_scan_request *req);
|
2011-05-11 14:09:36 +00:00
|
|
|
int ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_sched_scan_request *req);
|
2015-10-25 08:59:33 +00:00
|
|
|
int ieee80211_request_sched_scan_stop(struct ieee80211_local *local);
|
2014-04-30 12:19:04 +00:00
|
|
|
void ieee80211_sched_scan_end(struct ieee80211_local *local);
|
2011-05-12 13:28:29 +00:00
|
|
|
void ieee80211_sched_scan_stopped_work(struct work_struct *work);
|
2011-05-11 14:09:36 +00:00
|
|
|
|
2015-11-23 16:18:35 +00:00
|
|
|
/* off-channel/mgmt-tx */
|
2012-12-20 13:41:18 +00:00
|
|
|
void ieee80211_offchannel_stop_vifs(struct ieee80211_local *local);
|
|
|
|
void ieee80211_offchannel_return(struct ieee80211_local *local);
|
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 12:28:42 +00:00
|
|
|
void ieee80211_roc_setup(struct ieee80211_local *local);
|
|
|
|
void ieee80211_start_next_roc(struct ieee80211_local *local);
|
2013-03-27 21:49:19 +00:00
|
|
|
void ieee80211_roc_purge(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata);
|
2015-11-23 16:18:35 +00:00
|
|
|
int ieee80211_remain_on_channel(struct wiphy *wiphy, struct wireless_dev *wdev,
|
|
|
|
struct ieee80211_channel *chan,
|
|
|
|
unsigned int duration, u64 *cookie);
|
|
|
|
int ieee80211_cancel_remain_on_channel(struct wiphy *wiphy,
|
|
|
|
struct wireless_dev *wdev, u64 cookie);
|
|
|
|
int ieee80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
|
|
|
|
struct cfg80211_mgmt_tx_params *params, u64 *cookie);
|
|
|
|
int ieee80211_mgmt_tx_cancel_wait(struct wiphy *wiphy,
|
|
|
|
struct wireless_dev *wdev, u64 cookie);
|
2009-12-23 12:15:40 +00:00
|
|
|
|
2013-07-11 14:09:06 +00:00
|
|
|
/* channel switch handling */
|
|
|
|
void ieee80211_csa_finalize_work(struct work_struct *work);
|
2013-12-13 19:13:50 +00:00
|
|
|
int ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
struct cfg80211_csa_settings *params);
|
2013-07-11 14:09:06 +00:00
|
|
|
|
mac80211: make master netdev handling sane
Currently, almost every interface type has a 'bss' pointer
pointing to BSS information. This BSS information, however,
is for a _local_ BSS, not for the BSS we joined, so having
it on a STA mode interface makes little sense, but now they
have it pointing to the master device, which is an AP mode
virtual interface. However, except for some bitrate control
data, this pointer is only used in AP/VLAN modes (for power
saving stations.)
Overall, it is not necessary to even have the master netdev
be a valid virtual interface, and it doesn't have to be on
the list of interfaces either.
This patch changes the master netdev to be special, it now
- no longer is on the list of virtual interfaces, which
lets me remove a lot of tests for that
- no longer has sub_if_data attached, since that isn't used
Additionally, this patch changes some vlan/ap mode handling
that is related to these 'bss' pointers described above (but
in the VLAN case they actually make sense because there they
point to the AP they belong to); it also adds some debugging
code to IEEE80211_DEV_TO_SUB_IF to validate it is not called
on the master netdev any more.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-07-09 12:40:34 +00:00
|
|
|
/* interface handling */
|
2009-11-25 16:46:19 +00:00
|
|
|
int ieee80211_iface_init(void);
|
|
|
|
void ieee80211_iface_exit(void);
|
mac80211: make master netdev handling sane
Currently, almost every interface type has a 'bss' pointer
pointing to BSS information. This BSS information, however,
is for a _local_ BSS, not for the BSS we joined, so having
it on a STA mode interface makes little sense, but now they
have it pointing to the master device, which is an AP mode
virtual interface. However, except for some bitrate control
data, this pointer is only used in AP/VLAN modes (for power
saving stations.)
Overall, it is not necessary to even have the master netdev
be a valid virtual interface, and it doesn't have to be on
the list of interfaces either.
This patch changes the master netdev to be special, it now
- no longer is on the list of virtual interfaces, which
lets me remove a lot of tests for that
- no longer has sub_if_data attached, since that isn't used
Additionally, this patch changes some vlan/ap mode handling
that is related to these 'bss' pointers described above (but
in the VLAN case they actually make sense because there they
point to the AP they belong to); it also adds some debugging
code to IEEE80211_DEV_TO_SUB_IF to validate it is not called
on the master netdev any more.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-07-09 12:40:34 +00:00
|
|
|
int ieee80211_if_add(struct ieee80211_local *local, const char *name,
|
2015-03-18 10:13:39 +00:00
|
|
|
unsigned char name_assign_type,
|
2012-06-15 22:00:26 +00:00
|
|
|
struct wireless_dev **new_wdev, enum nl80211_iftype type,
|
2008-02-23 14:17:11 +00:00
|
|
|
struct vif_params *params);
|
2008-07-09 12:40:36 +00:00
|
|
|
int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
|
2008-09-10 22:01:58 +00:00
|
|
|
enum nl80211_iftype type);
|
2008-08-03 00:04:37 +00:00
|
|
|
void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata);
|
2008-07-09 12:40:35 +00:00
|
|
|
void ieee80211_remove_interfaces(struct ieee80211_local *local);
|
2013-03-22 21:30:09 +00:00
|
|
|
u32 ieee80211_idle_off(struct ieee80211_local *local);
|
2009-04-29 10:26:17 +00:00
|
|
|
void ieee80211_recalc_idle(struct ieee80211_local *local);
|
2010-10-02 11:17:07 +00:00
|
|
|
void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const int offset);
|
2012-06-18 18:07:15 +00:00
|
|
|
int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up);
|
|
|
|
void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata);
|
2013-03-27 22:20:27 +00:00
|
|
|
int ieee80211_add_virtual_monitor(struct ieee80211_local *local);
|
|
|
|
void ieee80211_del_virtual_monitor(struct ieee80211_local *local);
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2012-10-24 08:59:25 +00:00
|
|
|
bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata);
|
2015-01-14 11:55:08 +00:00
|
|
|
void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata,
|
|
|
|
bool update_bss);
|
2012-10-24 08:59:25 +00:00
|
|
|
|
2009-12-23 12:15:31 +00:00
|
|
|
static inline bool ieee80211_sdata_running(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
2010-08-27 10:35:58 +00:00
|
|
|
return test_bit(SDATA_STATE_RUNNING, &sdata->state);
|
2009-12-23 12:15:31 +00:00
|
|
|
}
|
|
|
|
|
2007-07-27 13:43:22 +00:00
|
|
|
/* tx handling */
|
|
|
|
void ieee80211_clear_tx_pending(struct ieee80211_local *local);
|
|
|
|
void ieee80211_tx_pending(unsigned long data);
|
2009-08-31 19:50:57 +00:00
|
|
|
netdev_tx_t ieee80211_monitor_start_xmit(struct sk_buff *skb,
|
|
|
|
struct net_device *dev);
|
|
|
|
netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb,
|
|
|
|
struct net_device *dev);
|
2014-11-09 16:50:07 +00:00
|
|
|
void __ieee80211_subif_start_xmit(struct sk_buff *skb,
|
|
|
|
struct net_device *dev,
|
|
|
|
u32 info_flags);
|
2012-11-10 02:44:14 +00:00
|
|
|
void ieee80211_purge_tx_queue(struct ieee80211_hw *hw,
|
|
|
|
struct sk_buff_head *skbs);
|
2014-11-09 16:50:11 +00:00
|
|
|
struct sk_buff *
|
|
|
|
ieee80211_build_data_template(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb, u32 info_flags);
|
2015-09-02 11:23:30 +00:00
|
|
|
void ieee80211_tx_monitor(struct ieee80211_local *local, struct sk_buff *skb,
|
|
|
|
struct ieee80211_supported_band *sband,
|
|
|
|
int retry_count, int shift, bool send_to_cooked);
|
2007-07-27 13:43:22 +00:00
|
|
|
|
2015-03-21 14:25:43 +00:00
|
|
|
void ieee80211_check_fast_xmit(struct sta_info *sta);
|
|
|
|
void ieee80211_check_fast_xmit_all(struct ieee80211_local *local);
|
|
|
|
void ieee80211_check_fast_xmit_iface(struct ieee80211_sub_if_data *sdata);
|
|
|
|
void ieee80211_clear_fast_xmit(struct sta_info *sta);
|
|
|
|
|
2008-09-09 12:42:50 +00:00
|
|
|
/* HT */
|
2011-11-18 19:32:00 +00:00
|
|
|
void ieee80211_apply_htcap_overrides(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_sta_ht_cap *ht_cap);
|
2013-02-07 10:47:44 +00:00
|
|
|
bool ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_sub_if_data *sdata,
|
2011-11-18 19:32:00 +00:00
|
|
|
struct ieee80211_supported_band *sband,
|
2013-02-12 15:43:19 +00:00
|
|
|
const struct ieee80211_ht_cap *ht_cap_ie,
|
2013-02-07 10:47:44 +00:00
|
|
|
struct sta_info *sta);
|
2009-02-10 20:25:46 +00:00
|
|
|
void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *da, u16 tid,
|
|
|
|
u16 initiator, u16 reason_code);
|
2009-12-01 12:37:02 +00:00
|
|
|
int ieee80211_send_smps_action(struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum ieee80211_smps_mode smps, const u8 *da,
|
|
|
|
const u8 *bssid);
|
2013-10-01 13:45:43 +00:00
|
|
|
void ieee80211_request_smps_ap_work(struct work_struct *work);
|
|
|
|
void ieee80211_request_smps_mgd_work(struct work_struct *work);
|
|
|
|
bool ieee80211_smps_is_restrictive(enum ieee80211_smps_mode smps_mode_old,
|
|
|
|
enum ieee80211_smps_mode smps_mode_new);
|
2008-09-09 12:42:50 +00:00
|
|
|
|
2010-06-10 08:21:44 +00:00
|
|
|
void ___ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
|
2010-10-05 17:37:40 +00:00
|
|
|
u16 initiator, u16 reason, bool stop);
|
2009-02-10 20:25:54 +00:00
|
|
|
void __ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
|
2010-10-05 17:37:40 +00:00
|
|
|
u16 initiator, u16 reason, bool stop);
|
2014-07-16 10:12:15 +00:00
|
|
|
void __ieee80211_start_rx_ba_session(struct sta_info *sta,
|
|
|
|
u8 dialog_token, u16 timeout,
|
|
|
|
u16 start_seq_num, u16 ba_policy, u16 tid,
|
2014-09-02 12:05:10 +00:00
|
|
|
u16 buf_size, bool tx, bool auto_seq);
|
2017-09-06 13:01:42 +00:00
|
|
|
void ___ieee80211_start_rx_ba_session(struct sta_info *sta,
|
|
|
|
u8 dialog_token, u16 timeout,
|
|
|
|
u16 start_seq_num, u16 ba_policy, u16 tid,
|
|
|
|
u16 buf_size, bool tx, bool auto_seq);
|
2012-07-18 11:31:31 +00:00
|
|
|
void ieee80211_sta_tear_down_BA_sessions(struct sta_info *sta,
|
|
|
|
enum ieee80211_agg_stop_reason reason);
|
2008-09-09 12:42:50 +00:00
|
|
|
void ieee80211_process_delba(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sta_info *sta,
|
|
|
|
struct ieee80211_mgmt *mgmt, size_t len);
|
|
|
|
void ieee80211_process_addba_resp(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta,
|
|
|
|
struct ieee80211_mgmt *mgmt,
|
|
|
|
size_t len);
|
|
|
|
void ieee80211_process_addba_request(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta,
|
|
|
|
struct ieee80211_mgmt *mgmt,
|
|
|
|
size_t len);
|
|
|
|
|
2009-02-10 20:25:54 +00:00
|
|
|
int __ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
|
2012-07-18 11:31:31 +00:00
|
|
|
enum ieee80211_agg_stop_reason reason);
|
2010-06-10 08:21:43 +00:00
|
|
|
int ___ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
|
2012-07-18 11:31:31 +00:00
|
|
|
enum ieee80211_agg_stop_reason reason);
|
2017-05-26 22:27:25 +00:00
|
|
|
void ieee80211_start_tx_ba_cb(struct sta_info *sta, int tid,
|
|
|
|
struct tid_ampdu_tx *tid_tx);
|
|
|
|
void ieee80211_stop_tx_ba_cb(struct sta_info *sta, int tid,
|
|
|
|
struct tid_ampdu_tx *tid_tx);
|
2010-06-10 08:21:43 +00:00
|
|
|
void ieee80211_ba_session_work(struct work_struct *work);
|
|
|
|
void ieee80211_tx_ba_session_handle_start(struct sta_info *sta, int tid);
|
2010-08-04 23:36:41 +00:00
|
|
|
void ieee80211_release_reorder_timeout(struct sta_info *sta, int tid);
|
2009-02-10 20:25:54 +00:00
|
|
|
|
2012-09-11 12:34:12 +00:00
|
|
|
u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs);
|
|
|
|
|
2012-10-10 11:33:04 +00:00
|
|
|
/* VHT */
|
2013-02-12 15:43:19 +00:00
|
|
|
void
|
|
|
|
ieee80211_vht_cap_ie_to_sta_vht_cap(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_supported_band *sband,
|
|
|
|
const struct ieee80211_vht_cap *vht_cap_ie,
|
|
|
|
struct sta_info *sta);
|
2014-12-14 09:05:51 +00:00
|
|
|
enum ieee80211_sta_rx_bandwidth ieee80211_sta_cap_rx_bw(struct sta_info *sta);
|
2013-02-07 10:47:44 +00:00
|
|
|
enum ieee80211_sta_rx_bandwidth ieee80211_sta_cur_vht_bw(struct sta_info *sta);
|
2012-12-27 17:26:42 +00:00
|
|
|
void ieee80211_sta_set_rx_nss(struct sta_info *sta);
|
2016-03-02 21:28:32 +00:00
|
|
|
enum ieee80211_sta_rx_bandwidth
|
|
|
|
ieee80211_chan_width_to_rx_bw(enum nl80211_chan_width width);
|
|
|
|
enum nl80211_chan_width ieee80211_sta_cap_chan_bw(struct sta_info *sta);
|
|
|
|
void ieee80211_sta_set_rx_nss(struct sta_info *sta);
|
2015-12-08 14:04:31 +00:00
|
|
|
void ieee80211_process_mu_groups(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_mgmt *mgmt);
|
2014-02-03 13:44:44 +00:00
|
|
|
u32 __ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sta_info *sta, u8 opmode,
|
2016-04-12 13:56:15 +00:00
|
|
|
enum nl80211_band band);
|
2012-12-27 17:55:36 +00:00
|
|
|
void ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sta_info *sta, u8 opmode,
|
2016-04-12 13:56:15 +00:00
|
|
|
enum nl80211_band band);
|
2013-02-21 16:40:19 +00:00
|
|
|
void ieee80211_apply_vhtcap_overrides(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_sta_vht_cap *vht_cap);
|
2015-08-06 21:47:33 +00:00
|
|
|
void ieee80211_get_vht_mask_from_cap(__le16 vht_cap,
|
|
|
|
u16 vht_mask[NL80211_VHT_NSS_MAX]);
|
2013-02-07 10:58:58 +00:00
|
|
|
|
2008-09-09 12:49:03 +00:00
|
|
|
/* Spectrum management */
|
|
|
|
void ieee80211_process_measurement_req(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_mgmt *mgmt,
|
|
|
|
size_t len);
|
2013-08-28 11:41:29 +00:00
|
|
|
/**
|
|
|
|
* ieee80211_parse_ch_switch_ie - parses channel switch IEs
|
|
|
|
* @sdata: the sdata of the interface which has received the frame
|
|
|
|
* @elems: parsed 802.11 elements received with the frame
|
|
|
|
* @current_band: indicates the current band
|
|
|
|
* @sta_flags: contains information about own capabilities and restrictions
|
|
|
|
* to decide which channel switch announcements can be accepted. Only the
|
|
|
|
* following subset of &enum ieee80211_sta_flags are evaluated:
|
|
|
|
* %IEEE80211_STA_DISABLE_HT, %IEEE80211_STA_DISABLE_VHT,
|
|
|
|
* %IEEE80211_STA_DISABLE_40MHZ, %IEEE80211_STA_DISABLE_80P80MHZ,
|
|
|
|
* %IEEE80211_STA_DISABLE_160MHZ.
|
|
|
|
* @bssid: the currently connected bssid (for reporting)
|
2013-10-15 02:08:29 +00:00
|
|
|
* @csa_ie: parsed 802.11 csa elements on count, mode, chandef and mesh ttl.
|
|
|
|
All of them will be filled with if success only.
|
2013-08-28 11:41:29 +00:00
|
|
|
* Return: 0 on success, <0 on error and >0 if there is nothing to parse.
|
|
|
|
*/
|
|
|
|
int ieee80211_parse_ch_switch_ie(struct ieee80211_sub_if_data *sdata,
|
2014-10-28 11:33:04 +00:00
|
|
|
struct ieee802_11_elems *elems,
|
2016-04-12 13:56:15 +00:00
|
|
|
enum nl80211_band current_band,
|
2013-10-15 02:08:29 +00:00
|
|
|
u32 sta_flags, u8 *bssid,
|
|
|
|
struct ieee80211_csa_ie *csa_ie);
|
2008-09-09 12:49:03 +00:00
|
|
|
|
2009-04-14 08:09:24 +00:00
|
|
|
/* Suspend/resume and hw reconfiguration */
|
|
|
|
int ieee80211_reconfig(struct ieee80211_local *local);
|
2009-08-20 18:02:20 +00:00
|
|
|
void ieee80211_stop_device(struct ieee80211_local *local);
|
2009-04-14 08:09:24 +00:00
|
|
|
|
2011-05-04 13:37:29 +00:00
|
|
|
int __ieee80211_suspend(struct ieee80211_hw *hw,
|
|
|
|
struct cfg80211_wowlan *wowlan);
|
2009-04-14 08:09:24 +00:00
|
|
|
|
|
|
|
static inline int __ieee80211_resume(struct ieee80211_hw *hw)
|
|
|
|
{
|
2010-09-01 20:12:28 +00:00
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
2015-01-24 08:30:02 +00:00
|
|
|
WARN(test_bit(SCAN_HW_SCANNING, &local->scanning) &&
|
|
|
|
!test_bit(SCAN_COMPLETED, &local->scanning),
|
2010-09-01 20:12:28 +00:00
|
|
|
"%s: resume with hardware scan still in progress\n",
|
|
|
|
wiphy_name(hw->wiphy));
|
|
|
|
|
2009-04-14 08:09:24 +00:00
|
|
|
return ieee80211_reconfig(hw_to_local(hw));
|
|
|
|
}
|
2009-01-19 16:20:53 +00:00
|
|
|
|
2007-07-27 13:43:23 +00:00
|
|
|
/* utility functions/constants */
|
2014-01-20 22:55:44 +00:00
|
|
|
extern const void *const mac80211_wiphy_privid; /* for wiphy privid */
|
2016-04-12 13:56:15 +00:00
|
|
|
int ieee80211_frame_duration(enum nl80211_band band, size_t len,
|
2013-07-08 14:55:51 +00:00
|
|
|
int rate, int erp, int short_preamble,
|
|
|
|
int shift);
|
2012-03-02 14:56:59 +00:00
|
|
|
void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
|
2015-10-22 15:46:04 +00:00
|
|
|
bool bss_notify, bool enable_qos);
|
2015-03-20 13:18:27 +00:00
|
|
|
void ieee80211_xmit(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sta_info *sta, struct sk_buff *skb);
|
2012-07-26 15:24:39 +00:00
|
|
|
|
|
|
|
void __ieee80211_tx_skb_tid_band(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb, int tid,
|
2016-04-12 13:56:15 +00:00
|
|
|
enum nl80211_band band);
|
2012-07-26 15:24:39 +00:00
|
|
|
|
|
|
|
static inline void
|
|
|
|
ieee80211_tx_skb_tid_band(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb, int tid,
|
2016-04-12 13:56:15 +00:00
|
|
|
enum nl80211_band band)
|
2012-07-26 15:24:39 +00:00
|
|
|
{
|
|
|
|
rcu_read_lock();
|
|
|
|
__ieee80211_tx_skb_tid_band(sdata, skb, tid, band);
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
2011-12-15 09:18:34 +00:00
|
|
|
|
2012-07-26 15:24:39 +00:00
|
|
|
static inline void ieee80211_tx_skb_tid(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb, int tid)
|
|
|
|
{
|
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
|
|
|
|
if (WARN_ON(!chanctx_conf)) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
kfree_skb(skb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
__ieee80211_tx_skb_tid_band(sdata, skb, tid,
|
2012-11-09 10:39:59 +00:00
|
|
|
chanctx_conf->def.chan->band);
|
2012-07-26 15:24:39 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ieee80211_tx_skb(struct ieee80211_sub_if_data *sdata,
|
2011-12-15 09:18:34 +00:00
|
|
|
struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
/* Send all internal mgmt frames on VO. Accordingly set TID to 7. */
|
|
|
|
ieee80211_tx_skb_tid(sdata, skb, 7);
|
|
|
|
}
|
|
|
|
|
2013-05-28 08:54:03 +00:00
|
|
|
u32 ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
|
mac80211: implement beacon filtering in software
Regardless of whether the hardware implements beacon filtering,
there's no need to process all beacons in software all the time
throughout the stack (mac80211 does a lot, then cfg80211, then
in the future possibly userspace).
This patch implements the "best possible" beacon filtering in
mac80211. "Best possible" means that it can look for changes in
all requested information elements, and distinguish vendor IEs
by their OUI.
In the future, we will add nl80211 API for userspace to request
information elements and vendor IE OUIs to watch -- drivers can
then implement the best they can do while software implements
it fully.
It is unclear whether or not this actually saves CPU time, but
the data is all in the cache already so it should be fairly
cheap. The additional _testing_, however, has great benefit;
Without this, and on hardware that doesn't implement beacon
filtering, wrong assumptions about, for example, scan result
updates could quickly creep into code.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-04-16 11:17:26 +00:00
|
|
|
struct ieee802_11_elems *elems,
|
|
|
|
u64 filter, u32 crc);
|
2013-05-28 08:54:03 +00:00
|
|
|
static inline void ieee802_11_parse_elems(const u8 *start, size_t len,
|
|
|
|
bool action,
|
2013-03-27 13:55:31 +00:00
|
|
|
struct ieee802_11_elems *elems)
|
|
|
|
{
|
2013-03-26 13:54:16 +00:00
|
|
|
ieee802_11_parse_elems_crc(start, len, action, elems, 0, 0);
|
2013-03-27 13:55:31 +00:00
|
|
|
}
|
|
|
|
|
2014-07-16 10:09:31 +00:00
|
|
|
|
2014-10-07 07:38:50 +00:00
|
|
|
extern const int ieee802_1d_to_ac[8];
|
|
|
|
|
|
|
|
static inline int ieee80211_ac_from_tid(int tid)
|
|
|
|
{
|
|
|
|
return ieee802_1d_to_ac[tid & 7];
|
|
|
|
}
|
|
|
|
|
2008-12-18 21:35:27 +00:00
|
|
|
void ieee80211_dynamic_ps_enable_work(struct work_struct *work);
|
|
|
|
void ieee80211_dynamic_ps_disable_work(struct work_struct *work);
|
|
|
|
void ieee80211_dynamic_ps_timer(unsigned long data);
|
2008-12-24 02:39:02 +00:00
|
|
|
void ieee80211_send_nullfunc(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata,
|
2015-09-24 14:14:55 +00:00
|
|
|
bool powersave);
|
2009-03-22 19:57:06 +00:00
|
|
|
void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_hdr *hdr);
|
2010-11-23 02:10:31 +00:00
|
|
|
void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata,
|
2014-10-07 07:38:50 +00:00
|
|
|
struct ieee80211_hdr *hdr, bool ack, u16 tx_time);
|
2008-12-18 21:35:27 +00:00
|
|
|
|
2008-12-18 21:35:20 +00:00
|
|
|
void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
|
2013-02-13 11:25:28 +00:00
|
|
|
unsigned long queues,
|
2014-06-13 13:30:05 +00:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted);
|
2014-06-13 13:30:06 +00:00
|
|
|
void ieee80211_stop_vif_queues(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum queue_stop_reason reason);
|
|
|
|
void ieee80211_wake_vif_queues(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum queue_stop_reason reason);
|
2008-12-18 21:35:20 +00:00
|
|
|
void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
|
2013-02-13 11:25:28 +00:00
|
|
|
unsigned long queues,
|
2014-06-13 13:30:05 +00:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted);
|
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-11 23:51:53 +00:00
|
|
|
void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
|
2014-06-13 13:30:05 +00:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted);
|
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-11 23:51:53 +00:00
|
|
|
void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
|
2014-06-13 13:30:05 +00:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted);
|
2012-04-03 14:28:50 +00:00
|
|
|
void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue);
|
2009-06-07 19:58:37 +00:00
|
|
|
void ieee80211_add_pending_skb(struct ieee80211_local *local,
|
|
|
|
struct sk_buff *skb);
|
2014-02-20 10:19:58 +00:00
|
|
|
void ieee80211_add_pending_skbs(struct ieee80211_local *local,
|
|
|
|
struct sk_buff_head *skbs);
|
2013-02-13 11:11:00 +00:00
|
|
|
void ieee80211_flush_queues(struct ieee80211_local *local,
|
2015-01-07 13:42:39 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata, bool drop);
|
2014-11-09 16:50:21 +00:00
|
|
|
void __ieee80211_flush_queues(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata,
|
2015-01-07 13:42:39 +00:00
|
|
|
unsigned int queues, bool drop);
|
2008-12-18 21:35:20 +00:00
|
|
|
|
2015-01-22 21:32:46 +00:00
|
|
|
static inline bool ieee80211_can_run_worker(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* If quiescing is set, we are racing with __ieee80211_suspend.
|
|
|
|
* __ieee80211_suspend flushes the workers after setting quiescing,
|
|
|
|
* and we check quiescing / suspended before enqueing new workers.
|
|
|
|
* We should abort the worker to avoid the races below.
|
|
|
|
*/
|
|
|
|
if (local->quiescing)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We might already be suspended if the following scenario occurs:
|
|
|
|
* __ieee80211_suspend Control path
|
|
|
|
*
|
|
|
|
* if (local->quiescing)
|
|
|
|
* return;
|
|
|
|
* local->quiescing = true;
|
|
|
|
* flush_workqueue();
|
|
|
|
* queue_work(...);
|
|
|
|
* local->suspended = true;
|
|
|
|
* local->quiescing = false;
|
|
|
|
* worker starts running...
|
|
|
|
*/
|
|
|
|
if (local->suspended)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-05-19 08:37:49 +00:00
|
|
|
int ieee80211_txq_setup_flows(struct ieee80211_local *local);
|
|
|
|
void ieee80211_txq_teardown_flows(struct ieee80211_local *local);
|
|
|
|
void ieee80211_txq_init(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sta_info *sta,
|
|
|
|
struct txq_info *txq, int tid);
|
|
|
|
void ieee80211_txq_purge(struct ieee80211_local *local,
|
|
|
|
struct txq_info *txqi);
|
2009-02-15 11:44:28 +00:00
|
|
|
void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
|
2012-09-30 16:29:37 +00:00
|
|
|
u16 transaction, u16 auth_alg, u16 status,
|
2013-02-12 15:43:19 +00:00
|
|
|
const u8 *extra, size_t extra_len, const u8 *bssid,
|
2013-01-29 14:02:27 +00:00
|
|
|
const u8 *da, const u8 *key, u8 key_len, u8 key_idx,
|
|
|
|
u32 tx_flags);
|
2012-09-07 11:28:52 +00:00
|
|
|
void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *bssid, u16 stype, u16 reason,
|
|
|
|
bool send_frame, u8 *frame_buf);
|
2009-04-01 09:58:36 +00:00
|
|
|
int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
|
2014-02-05 13:21:13 +00:00
|
|
|
size_t buffer_len,
|
|
|
|
struct ieee80211_scan_ies *ie_desc,
|
|
|
|
const u8 *ie, size_t ie_len,
|
|
|
|
u8 bands_used, u32 *rate_masks,
|
2013-07-08 14:55:53 +00:00
|
|
|
struct cfg80211_chan_def *chandef);
|
2010-11-11 06:50:18 +00:00
|
|
|
struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
|
2014-06-12 20:24:31 +00:00
|
|
|
const u8 *src, const u8 *dst,
|
|
|
|
u32 ratemask,
|
2012-07-23 12:53:27 +00:00
|
|
|
struct ieee80211_channel *chan,
|
2010-11-11 06:50:18 +00:00
|
|
|
const u8 *ssid, size_t ssid_len,
|
2011-06-23 17:00:11 +00:00
|
|
|
const u8 *ie, size_t ie_len,
|
|
|
|
bool directed);
|
2014-06-12 20:24:31 +00:00
|
|
|
void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *src, const u8 *dst,
|
2009-04-01 09:58:36 +00:00
|
|
|
const u8 *ssid, size_t ssid_len,
|
2011-06-23 17:00:11 +00:00
|
|
|
const u8 *ie, size_t ie_len,
|
2013-01-29 14:02:27 +00:00
|
|
|
u32 ratemask, bool directed, u32 tx_flags,
|
2012-07-26 15:24:39 +00:00
|
|
|
struct ieee80211_channel *channel, bool scan);
|
2009-02-15 11:44:28 +00:00
|
|
|
|
2013-07-08 14:55:53 +00:00
|
|
|
u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata,
|
2009-02-15 11:44:28 +00:00
|
|
|
struct ieee802_11_elems *elems,
|
2016-04-12 13:56:15 +00:00
|
|
|
enum nl80211_band band, u32 *basic_rates);
|
2013-10-01 13:45:43 +00:00
|
|
|
int __ieee80211_request_smps_mgd(struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum ieee80211_smps_mode smps_mode);
|
|
|
|
int __ieee80211_request_smps_ap(struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum ieee80211_smps_mode smps_mode);
|
2012-09-11 12:34:12 +00:00
|
|
|
void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata);
|
2013-11-11 18:14:01 +00:00
|
|
|
void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata);
|
2009-02-15 11:44:28 +00:00
|
|
|
|
2009-12-23 12:15:38 +00:00
|
|
|
size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset);
|
2011-11-18 19:32:00 +00:00
|
|
|
u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
|
2011-10-26 21:47:26 +00:00
|
|
|
u16 cap);
|
2012-03-15 18:45:16 +00:00
|
|
|
u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
|
2012-11-09 10:39:59 +00:00
|
|
|
const struct cfg80211_chan_def *chandef,
|
2015-10-25 08:59:34 +00:00
|
|
|
u16 prot_mode, bool rifs_mode);
|
2017-05-23 15:00:42 +00:00
|
|
|
void ieee80211_ie_build_wide_bw_cs(u8 *pos,
|
|
|
|
const struct cfg80211_chan_def *chandef);
|
2012-07-02 11:25:12 +00:00
|
|
|
u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
|
|
|
|
u32 cap);
|
2015-03-01 07:10:02 +00:00
|
|
|
u8 *ieee80211_ie_build_vht_oper(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
|
|
|
|
const struct cfg80211_chan_def *chandef);
|
2013-07-08 14:55:53 +00:00
|
|
|
int ieee80211_parse_bitrates(struct cfg80211_chan_def *chandef,
|
|
|
|
const struct ieee80211_supported_band *sband,
|
|
|
|
const u8 *srates, int srates_len, u32 *rates);
|
2012-06-28 08:33:25 +00:00
|
|
|
int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata,
|
2012-07-23 12:53:27 +00:00
|
|
|
struct sk_buff *skb, bool need_basic,
|
2016-04-12 13:56:15 +00:00
|
|
|
enum nl80211_band band);
|
2012-06-28 08:33:25 +00:00
|
|
|
int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata,
|
2012-07-23 12:53:27 +00:00
|
|
|
struct sk_buff *skb, bool need_basic,
|
2016-04-12 13:56:15 +00:00
|
|
|
enum nl80211_band band);
|
2014-07-17 14:14:23 +00:00
|
|
|
u8 *ieee80211_add_wmm_info_ie(u8 *buf, u8 qosinfo);
|
2009-12-23 12:15:38 +00:00
|
|
|
|
cfg80211/mac80211: better channel handling
Currently (all tested with hwsim) you can do stupid
things like setting up an AP on a certain channel,
then adding another virtual interface and making
that associate on another channel -- this will make
the beaconing to move channel but obviously without
the necessary IEs data update.
In order to improve this situation, first make the
configuration APIs (cfg80211 and nl80211) aware of
multi-channel operation -- we'll eventually need
that in the future anyway. There's one userland API
change and one API addition. The API change is that
now SET_WIPHY must be called with virtual interface
index rather than only wiphy index in order to take
effect for that interface -- luckily all current
users (hostapd) do that. For monitor interfaces, the
old setting is preserved, but monitors are always
slaved to other devices anyway so no guarantees.
The second userland API change is the introduction
of a per virtual interface SET_CHANNEL command, that
hostapd should use going forward to make it easier
to understand what's going on (it can automatically
detect a kernel with this command).
Other than mac80211, no existing cfg80211 drivers
are affected by this change because they only allow
a single virtual interface.
mac80211, however, now needs to be aware that the
channel settings are per interface now, and needs
to disallow (for now) real multi-channel operation,
which is another important part of this patch.
One of the immediate benefits is that you can now
start hostapd to operate on a hardware that already
has a connection on another virtual interface, as
long as you specify the same channel.
Note that two things are left unhandled (this is an
improvement -- not a complete fix):
* different HT/no-HT modes
currently you could start an HT AP and then
connect to a non-HT network on the same channel
which would configure the hardware for no HT;
that can be fixed fairly easily
* CSA
An AP we're connected to on a virtual interface
might indicate switching channels, and in that
case we would follow it, regardless of how many
other interfaces are operating; this requires
more effort to fix but is pretty rare after all
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-05-05 13:25:02 +00:00
|
|
|
/* channel management */
|
2015-12-18 14:08:34 +00:00
|
|
|
bool ieee80211_chandef_ht_oper(const struct ieee80211_ht_operation *ht_oper,
|
|
|
|
struct cfg80211_chan_def *chandef);
|
|
|
|
bool ieee80211_chandef_vht_oper(const struct ieee80211_vht_operation *oper,
|
|
|
|
struct cfg80211_chan_def *chandef);
|
2013-08-28 11:41:29 +00:00
|
|
|
u32 ieee80211_chandef_downgrade(struct cfg80211_chan_def *c);
|
cfg80211/mac80211: better channel handling
Currently (all tested with hwsim) you can do stupid
things like setting up an AP on a certain channel,
then adding another virtual interface and making
that associate on another channel -- this will make
the beaconing to move channel but obviously without
the necessary IEs data update.
In order to improve this situation, first make the
configuration APIs (cfg80211 and nl80211) aware of
multi-channel operation -- we'll eventually need
that in the future anyway. There's one userland API
change and one API addition. The API change is that
now SET_WIPHY must be called with virtual interface
index rather than only wiphy index in order to take
effect for that interface -- luckily all current
users (hostapd) do that. For monitor interfaces, the
old setting is preserved, but monitors are always
slaved to other devices anyway so no guarantees.
The second userland API change is the introduction
of a per virtual interface SET_CHANNEL command, that
hostapd should use going forward to make it easier
to understand what's going on (it can automatically
detect a kernel with this command).
Other than mac80211, no existing cfg80211 drivers
are affected by this change because they only allow
a single virtual interface.
mac80211, however, now needs to be aware that the
channel settings are per interface now, and needs
to disallow (for now) real multi-channel operation,
which is another important part of this patch.
One of the immediate benefits is that you can now
start hostapd to operate on a hardware that already
has a connection on another virtual interface, as
long as you specify the same channel.
Note that two things are left unhandled (this is an
improvement -- not a complete fix):
* different HT/no-HT modes
currently you could start an HT AP and then
connect to a non-HT network on the same channel
which would configure the hardware for no HT;
that can be fixed fairly easily
* CSA
An AP we're connected to on a virtual interface
might indicate switching channels, and in that
case we would follow it, regardless of how many
other interfaces are operating; this requires
more effort to fix but is pretty rare after all
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-05-05 13:25:02 +00:00
|
|
|
|
2012-06-26 12:37:16 +00:00
|
|
|
int __must_check
|
|
|
|
ieee80211_vif_use_channel(struct ieee80211_sub_if_data *sdata,
|
2012-11-09 10:39:59 +00:00
|
|
|
const struct cfg80211_chan_def *chandef,
|
2012-06-26 12:37:16 +00:00
|
|
|
enum ieee80211_chanctx_mode mode);
|
2013-10-30 11:09:39 +00:00
|
|
|
int __must_check
|
|
|
|
ieee80211_vif_reserve_chanctx(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const struct cfg80211_chan_def *chandef,
|
2014-04-09 13:29:25 +00:00
|
|
|
enum ieee80211_chanctx_mode mode,
|
|
|
|
bool radar_required);
|
2013-10-30 11:09:39 +00:00
|
|
|
int __must_check
|
2014-06-25 10:35:06 +00:00
|
|
|
ieee80211_vif_use_reserved_context(struct ieee80211_sub_if_data *sdata);
|
2013-10-30 11:09:39 +00:00
|
|
|
int ieee80211_vif_unreserve_chanctx(struct ieee80211_sub_if_data *sdata);
|
|
|
|
|
2013-02-07 20:37:29 +00:00
|
|
|
int __must_check
|
|
|
|
ieee80211_vif_change_bandwidth(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const struct cfg80211_chan_def *chandef,
|
|
|
|
u32 *changed);
|
2012-06-26 12:37:16 +00:00
|
|
|
void ieee80211_vif_release_channel(struct ieee80211_sub_if_data *sdata);
|
2012-12-11 19:38:41 +00:00
|
|
|
void ieee80211_vif_vlan_copy_chanctx(struct ieee80211_sub_if_data *sdata);
|
2013-02-08 11:07:44 +00:00
|
|
|
void ieee80211_vif_copy_chanctx_to_vlans(struct ieee80211_sub_if_data *sdata,
|
|
|
|
bool clear);
|
2014-04-09 13:29:33 +00:00
|
|
|
int ieee80211_chanctx_refcount(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_chanctx *ctx);
|
2012-06-26 12:37:16 +00:00
|
|
|
|
2012-09-11 12:34:12 +00:00
|
|
|
void ieee80211_recalc_smps_chanctx(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_chanctx *chanctx);
|
2013-11-11 18:14:01 +00:00
|
|
|
void ieee80211_recalc_chanctx_min_def(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_chanctx *ctx);
|
2015-01-07 15:50:09 +00:00
|
|
|
bool ieee80211_is_radar_required(struct ieee80211_local *local);
|
2013-02-08 17:16:20 +00:00
|
|
|
|
|
|
|
void ieee80211_dfs_cac_timer(unsigned long data);
|
|
|
|
void ieee80211_dfs_cac_timer_work(struct work_struct *work);
|
|
|
|
void ieee80211_dfs_cac_cancel(struct ieee80211_local *local);
|
|
|
|
void ieee80211_dfs_radar_detected_work(struct work_struct *work);
|
2013-10-15 02:08:28 +00:00
|
|
|
int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_csa_settings *csa_settings);
|
2012-09-11 12:34:12 +00:00
|
|
|
|
2013-03-24 12:23:27 +00:00
|
|
|
bool ieee80211_cs_valid(const struct ieee80211_cipher_scheme *cs);
|
|
|
|
bool ieee80211_cs_list_valid(const struct ieee80211_cipher_scheme *cs, int n);
|
|
|
|
const struct ieee80211_cipher_scheme *
|
|
|
|
ieee80211_cs_get(struct ieee80211_local *local, u32 cipher,
|
|
|
|
enum nl80211_iftype iftype);
|
|
|
|
int ieee80211_cs_headroom(struct ieee80211_local *local,
|
|
|
|
struct cfg80211_crypto_settings *crypto,
|
|
|
|
enum nl80211_iftype iftype);
|
2013-12-19 18:25:15 +00:00
|
|
|
void ieee80211_recalc_dtim(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata);
|
2014-02-13 09:31:59 +00:00
|
|
|
int ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const struct cfg80211_chan_def *chandef,
|
|
|
|
enum ieee80211_chanctx_mode chanmode,
|
|
|
|
u8 radar_detect);
|
2014-04-09 13:29:23 +00:00
|
|
|
int ieee80211_max_num_channels(struct ieee80211_local *local);
|
2015-06-10 17:41:23 +00:00
|
|
|
enum nl80211_chan_width ieee80211_get_sta_bw(struct ieee80211_sta *sta);
|
|
|
|
void ieee80211_recalc_chanctx_chantype(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_chanctx *ctx);
|
2013-03-24 12:23:27 +00:00
|
|
|
|
2014-05-01 07:17:28 +00:00
|
|
|
/* TDLS */
|
|
|
|
int ieee80211_tdls_mgmt(struct wiphy *wiphy, struct net_device *dev,
|
2014-05-19 15:19:31 +00:00
|
|
|
const u8 *peer, u8 action_code, u8 dialog_token,
|
2014-05-01 07:17:28 +00:00
|
|
|
u16 status_code, u32 peer_capability,
|
2014-06-11 14:18:21 +00:00
|
|
|
bool initiator, const u8 *extra_ies,
|
|
|
|
size_t extra_ies_len);
|
2014-05-01 07:17:28 +00:00
|
|
|
int ieee80211_tdls_oper(struct wiphy *wiphy, struct net_device *dev,
|
2014-05-19 15:19:31 +00:00
|
|
|
const u8 *peer, enum nl80211_tdls_operation oper);
|
2014-09-05 08:56:35 +00:00
|
|
|
void ieee80211_tdls_peer_del_work(struct work_struct *wk);
|
2014-11-09 16:50:19 +00:00
|
|
|
int ieee80211_tdls_channel_switch(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
const u8 *addr, u8 oper_class,
|
|
|
|
struct cfg80211_chan_def *chandef);
|
|
|
|
void ieee80211_tdls_cancel_channel_switch(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
const u8 *addr);
|
2015-06-14 13:53:46 +00:00
|
|
|
void ieee80211_teardown_tdls_peers(struct ieee80211_sub_if_data *sdata);
|
2015-07-08 12:41:45 +00:00
|
|
|
void ieee80211_tdls_chsw_work(struct work_struct *wk);
|
mac80211: handle deauthentication/disassociation from TDLS peer
commit 79c92ca42b5a3e0ea172ea2ce8df8e125af237da upstream.
When receiving a deauthentication/disassociation frame from a TDLS
peer, a station should not disconnect the current AP, but only
disable the current TDLS link if it's enabled.
Without this change, a TDLS issue can be reproduced by following the
steps as below:
1. STA-1 and STA-2 are connected to AP, bidirection traffic is running
between STA-1 and STA-2.
2. Set up TDLS link between STA-1 and STA-2, stay for a while, then
teardown TDLS link.
3. Repeat step #2 and monitor the connection between STA and AP.
During the test, one STA may send a deauthentication/disassociation
frame to another, after TDLS teardown, with reason code 6/7, which
means: Class 2/3 frame received from nonassociated STA.
On receive this frame, the receiver STA will disconnect the current
AP and then reconnect. It's not a expected behavior, purpose of this
frame should be disabling the TDLS link, not the link with AP.
Cc: stable@vger.kernel.org
Signed-off-by: Yu Wang <yyuwang@codeaurora.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-05-10 09:04:52 +00:00
|
|
|
void ieee80211_tdls_handle_disconnect(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *peer, u16 reason);
|
|
|
|
const char *ieee80211_get_reason_code_string(u16 reason_code);
|
2014-05-01 07:17:28 +00:00
|
|
|
|
2014-06-04 15:31:56 +00:00
|
|
|
extern const struct ethtool_ops ieee80211_ethtool_ops;
|
|
|
|
|
2008-06-30 13:10:46 +00:00
|
|
|
#ifdef CONFIG_MAC80211_NOINLINE
|
2008-06-30 13:10:44 +00:00
|
|
|
#define debug_noinline noinline
|
|
|
|
#else
|
|
|
|
#define debug_noinline
|
|
|
|
#endif
|
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
#endif /* IEEE80211_I_H */
|