2019-06-04 08:11:33 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-only */
|
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
|
2022-02-09 12:14:26 +00:00
|
|
|
* Copyright (C) 2018-2022 Intel Corporation
|
2007-05-05 18:45:53 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#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>
|
2021-07-15 16:02:35 +00:00
|
|
|
#include <linux/rbtree.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
|
|
|
|
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
|
|
|
|
|
2022-06-25 21:24:08 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Keep a station's queues on the active list for deficit accounting purposes
|
|
|
|
* if it was active or queued during the last 100ms
|
|
|
|
*/
|
|
|
|
#define AIRTIME_ACTIVE_DURATION (HZ / 10)
|
|
|
|
|
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
|
|
|
|
2020-05-28 19:34:35 +00:00
|
|
|
u32 vht_cap_info;
|
|
|
|
|
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 {
|
2020-07-26 11:06:11 +00:00
|
|
|
struct list_head *list;
|
2007-05-05 18:45:53 +00:00
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_local *local;
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2022-07-21 11:08:13 +00:00
|
|
|
struct ieee80211_link_data *link;
|
2007-05-05 18:45:53 +00:00
|
|
|
struct sta_info *sta;
|
2022-08-17 09:17:01 +00:00
|
|
|
struct link_sta_info *link_sta;
|
2007-05-05 18:45:53 +00:00
|
|
|
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;
|
|
|
|
|
2022-06-14 11:08:42 +00:00
|
|
|
int link_id;
|
|
|
|
|
2021-05-11 18:02:48 +00:00
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
u32 iv32;
|
|
|
|
u16 iv16;
|
|
|
|
} tkip;
|
|
|
|
struct {
|
|
|
|
u8 pn[IEEE80211_CCMP_PN_LEN];
|
|
|
|
} ccm_gcm;
|
|
|
|
};
|
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;
|
|
|
|
};
|
|
|
|
|
2021-07-02 17:44:08 +00:00
|
|
|
struct ieee80211_color_change_settings {
|
|
|
|
u16 counter_offset_beacon;
|
|
|
|
u16 counter_offset_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;
|
2020-08-11 08:01:04 +00:00
|
|
|
u16 cntdwn_counter_offsets[IEEE80211_MAX_CNTDWN_COUNTERS_NUM];
|
|
|
|
u8 cntdwn_current_counter;
|
2022-02-24 11:54:58 +00:00
|
|
|
struct cfg80211_mbssid_elems *mbssid_ies;
|
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;
|
2020-08-11 08:01:04 +00:00
|
|
|
u16 cntdwn_counter_offsets[IEEE80211_MAX_CNTDWN_COUNTERS_NUM];
|
2020-05-07 18:59:07 +00:00
|
|
|
u8 data[];
|
2012-08-06 11:26:16 +00:00
|
|
|
};
|
|
|
|
|
2020-09-11 00:05:31 +00:00
|
|
|
struct fils_discovery_data {
|
|
|
|
struct rcu_head rcu_head;
|
|
|
|
int len;
|
|
|
|
u8 data[];
|
|
|
|
};
|
|
|
|
|
2020-09-11 00:33:01 +00:00
|
|
|
struct unsol_bcast_probe_resp_data {
|
|
|
|
struct rcu_head rcu_head;
|
|
|
|
int len;
|
|
|
|
u8 data[];
|
|
|
|
};
|
|
|
|
|
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 {
|
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
|
|
|
|
2016-11-22 10:52:18 +00:00
|
|
|
bool multicast_to_unicast;
|
2022-05-16 13:00:15 +00:00
|
|
|
bool active;
|
2012-10-10 19:39:50 +00:00
|
|
|
};
|
|
|
|
|
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 */
|
|
|
|
};
|
|
|
|
|
|
|
|
#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),
|
|
|
|
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),
|
2014-09-03 12:25:02 +00:00
|
|
|
IEEE80211_STA_ENABLE_RRM = BIT(15),
|
2022-06-23 10:04:55 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef u32 __bitwise ieee80211_conn_flags_t;
|
|
|
|
|
|
|
|
enum ieee80211_conn_flags {
|
|
|
|
IEEE80211_CONN_DISABLE_HT = (__force ieee80211_conn_flags_t)BIT(0),
|
|
|
|
IEEE80211_CONN_DISABLE_40MHZ = (__force ieee80211_conn_flags_t)BIT(1),
|
|
|
|
IEEE80211_CONN_DISABLE_VHT = (__force ieee80211_conn_flags_t)BIT(2),
|
|
|
|
IEEE80211_CONN_DISABLE_80P80MHZ = (__force ieee80211_conn_flags_t)BIT(3),
|
|
|
|
IEEE80211_CONN_DISABLE_160MHZ = (__force ieee80211_conn_flags_t)BIT(4),
|
|
|
|
IEEE80211_CONN_DISABLE_HE = (__force ieee80211_conn_flags_t)BIT(5),
|
|
|
|
IEEE80211_CONN_DISABLE_EHT = (__force ieee80211_conn_flags_t)BIT(6),
|
|
|
|
IEEE80211_CONN_DISABLE_320MHZ = (__force ieee80211_conn_flags_t)BIT(7),
|
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;
|
2022-02-24 09:39:34 +00:00
|
|
|
bool done, waiting;
|
2018-10-10 21:21:21 +00:00
|
|
|
bool peer_confirmed;
|
2013-02-13 14:39:57 +00:00
|
|
|
bool timeout_started;
|
2022-09-21 21:01:46 +00:00
|
|
|
int link_id;
|
2012-01-20 12:55:27 +00:00
|
|
|
|
2022-06-01 19:17:34 +00:00
|
|
|
u8 ap_addr[ETH_ALEN] __aligned(2);
|
|
|
|
|
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 {
|
2022-06-01 19:17:34 +00:00
|
|
|
struct {
|
|
|
|
struct cfg80211_bss *bss;
|
|
|
|
|
|
|
|
u8 addr[ETH_ALEN] __aligned(2);
|
|
|
|
|
|
|
|
u8 ap_ht_param;
|
|
|
|
|
|
|
|
struct ieee80211_vht_cap ap_vht_cap;
|
|
|
|
|
|
|
|
size_t elems_len;
|
|
|
|
u8 *elems; /* pointing to inside ie[] below */
|
|
|
|
|
|
|
|
ieee80211_conn_flags_t conn_flags;
|
2022-09-08 08:31:10 +00:00
|
|
|
|
|
|
|
u16 status;
|
2022-06-01 19:17:34 +00:00
|
|
|
} link[IEEE80211_MLD_MAX_NUM_LINKS];
|
|
|
|
|
|
|
|
u8 ap_addr[ETH_ALEN] __aligned(2);
|
|
|
|
|
|
|
|
/* this is for a workaround, so we use it only for non-MLO */
|
2012-01-20 12:55:27 +00:00
|
|
|
const u8 *supp_rates;
|
2022-06-01 19:17:34 +00:00
|
|
|
u8 supp_rates_len;
|
2012-01-20 12:55:27 +00:00
|
|
|
|
|
|
|
unsigned long timeout;
|
|
|
|
int tries;
|
|
|
|
|
2022-06-01 19:17:34 +00:00
|
|
|
u8 prev_ap_addr[ETH_ALEN];
|
2012-01-20 12:55:27 +00:00
|
|
|
u8 ssid[IEEE80211_MAX_SSID_LEN];
|
|
|
|
u8 ssid_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;
|
2022-06-01 19:17:34 +00:00
|
|
|
bool s1g;
|
2012-01-20 12:55:27 +00:00
|
|
|
|
2022-06-01 19:17:34 +00:00
|
|
|
unsigned int assoc_link_id;
|
2012-12-07 12:06:48 +00:00
|
|
|
|
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;
|
2022-06-01 19:17:34 +00:00
|
|
|
u8 *ie_pos; /* used to fill ie[] with link[].elems */
|
2012-01-20 12:55:27 +00:00
|
|
|
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;
|
|
|
|
struct work_struct monitor_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;
|
2020-12-06 12:54:43 +00:00
|
|
|
u8 connection_loss:1,
|
|
|
|
driver_disconnect:1,
|
2022-05-13 16:03:14 +00:00
|
|
|
reconnect:1,
|
|
|
|
associated:1;
|
2009-07-10 13:29:03 +00:00
|
|
|
|
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
|
|
|
|
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 */
|
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
|
|
|
|
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;
|
|
|
|
|
2009-11-19 10:55:19 +00:00
|
|
|
u8 use_4addr;
|
2010-03-30 06:28:30 +00:00
|
|
|
|
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;
|
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 */
|
2020-09-22 02:28:05 +00:00
|
|
|
struct ieee80211_s1g_cap s1g_capa; /* configured S1G overrides */
|
|
|
|
struct ieee80211_s1g_cap s1g_capa_mask; /* valid s1g_capa bits */
|
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 */
|
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;
|
2019-02-15 00:14:33 +00:00
|
|
|
|
|
|
|
/* Information elements from the last transmitted (Re)Association
|
|
|
|
* Request frame.
|
|
|
|
*/
|
|
|
|
u8 *assoc_req_ies;
|
|
|
|
size_t assoc_req_ies_len;
|
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 {
|
2021-09-20 13:40:07 +00:00
|
|
|
void (*rx_bcn_presp)(struct ieee80211_sub_if_data *sdata, u16 stype,
|
|
|
|
struct ieee80211_mgmt *mgmt, unsigned int len,
|
|
|
|
const struct ieee80211_meshconf_ie *mesh_cfg,
|
2012-03-31 18:31:32 +00:00
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
2021-12-30 19:55:47 +00:00
|
|
|
/**
|
|
|
|
* struct mesh_table
|
|
|
|
*
|
|
|
|
* @known_gates: list of known mesh gates and their mpaths by the station. The
|
|
|
|
* gate's mpath may or may not be resolved and active.
|
|
|
|
* @gates_lock: protects updates to known_gates
|
|
|
|
* @rhead: the rhashtable containing struct mesh_paths, keyed by dest addr
|
|
|
|
* @walk_head: linked list containing all mesh_path objects
|
|
|
|
* @walk_lock: lock protecting walk_head
|
|
|
|
* @entries: number of entries in the table
|
|
|
|
*/
|
|
|
|
struct mesh_table {
|
|
|
|
struct hlist_head known_gates;
|
|
|
|
spinlock_t gates_lock;
|
|
|
|
struct rhashtable rhead;
|
|
|
|
struct hlist_head walk_head;
|
|
|
|
spinlock_t walk_lock;
|
|
|
|
atomic_t entries; /* Up to MAX_MESH_NEIGHBOURS */
|
|
|
|
};
|
|
|
|
|
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
|
|
|
|
2021-12-30 19:55:47 +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_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
|
2022-03-08 11:53:24 +00:00
|
|
|
* @IEEE80211_SDATA_DISCONNECT_HW_RESTART: Disconnect after hardware restart
|
|
|
|
* recovery
|
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_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),
|
2022-03-08 11:53:24 +00:00
|
|
|
IEEE80211_SDATA_DISCONNECT_HW_RESTART = BIT(6),
|
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;
|
|
|
|
|
2022-05-30 16:35:23 +00:00
|
|
|
struct list_head assigned_links;
|
|
|
|
struct list_head reserved_links;
|
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,
|
2022-12-30 12:18:49 +00:00
|
|
|
IEEE80211_TXQ_DIRTY,
|
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
|
2021-06-23 13:47:55 +00:00
|
|
|
* @frags: used to keep fragments created after dequeue
|
2022-06-25 21:24:05 +00:00
|
|
|
* @schedule_order: used with ieee80211_local->active_txqs
|
|
|
|
* @schedule_round: counter to prevent infinite loops on TXQ scheduling
|
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;
|
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;
|
2022-06-25 21:24:05 +00:00
|
|
|
|
|
|
|
u16 schedule_round;
|
|
|
|
struct list_head schedule_order;
|
2021-06-18 10:41:44 +00:00
|
|
|
|
|
|
|
struct sk_buff_head frags;
|
2022-06-25 21:24:05 +00:00
|
|
|
|
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
|
|
|
};
|
|
|
|
|
2022-05-16 13:00:15 +00:00
|
|
|
struct ieee80211_link_data_managed {
|
|
|
|
u8 bssid[ETH_ALEN] __aligned(2);
|
|
|
|
|
|
|
|
u8 dtim_period;
|
|
|
|
enum ieee80211_smps_mode req_smps, /* requested smps mode */
|
|
|
|
driver_smps_mode; /* smps mode request */
|
|
|
|
|
2022-06-23 10:04:55 +00:00
|
|
|
ieee80211_conn_flags_t conn_flags;
|
|
|
|
|
2022-05-16 13:00:15 +00:00
|
|
|
s16 p2p_noa_index;
|
|
|
|
|
2022-06-29 10:01:41 +00:00
|
|
|
bool tdls_chan_switch_prohibited;
|
|
|
|
|
2022-05-16 13:00:15 +00:00
|
|
|
bool have_beacon;
|
2022-06-24 14:28:33 +00:00
|
|
|
bool tracking_signal_avg;
|
2022-06-27 11:13:04 +00:00
|
|
|
bool disable_wmm_tracking;
|
2022-07-12 08:49:23 +00:00
|
|
|
bool operating_11g_mode;
|
2022-05-16 13:00:15 +00:00
|
|
|
|
|
|
|
bool csa_waiting_bcn;
|
|
|
|
bool csa_ignored_same_chan;
|
2022-06-24 14:18:56 +00:00
|
|
|
struct timer_list chswitch_timer;
|
|
|
|
struct work_struct chswitch_work;
|
2022-05-16 13:00:15 +00:00
|
|
|
|
|
|
|
struct work_struct request_smps_work;
|
|
|
|
bool beacon_crc_valid;
|
|
|
|
u32 beacon_crc;
|
|
|
|
struct ewma_beacon_signal ave_beacon_signal;
|
|
|
|
int last_ave_beacon_signal;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
/* Number of times beacon loss was invoked. */
|
|
|
|
unsigned int beacon_loss_count;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
int wmm_last_param_set;
|
|
|
|
int mu_edca_last_param_set;
|
|
|
|
|
|
|
|
struct cfg80211_bss *bss;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ieee80211_link_data_ap {
|
|
|
|
struct beacon_data __rcu *beacon;
|
|
|
|
struct probe_resp __rcu *probe_resp;
|
|
|
|
struct fils_discovery_data __rcu *fils_discovery;
|
|
|
|
struct unsol_bcast_probe_resp_data __rcu *unsol_bcast_probe_resp;
|
|
|
|
|
|
|
|
/* to be used after channel switch. */
|
|
|
|
struct cfg80211_beacon_data *next_beacon;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ieee80211_link_data {
|
2022-05-30 16:35:23 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
unsigned int link_id;
|
|
|
|
|
|
|
|
struct list_head assigned_chanctx_list; /* protected by chanctx_mtx */
|
|
|
|
struct list_head reserved_chanctx_list; /* protected by chanctx_mtx */
|
|
|
|
|
2022-05-16 13:00:15 +00:00
|
|
|
/* multicast keys only */
|
|
|
|
struct ieee80211_key __rcu *gtk[NUM_DEFAULT_KEYS +
|
|
|
|
NUM_DEFAULT_MGMT_KEYS +
|
|
|
|
NUM_DEFAULT_BEACON_KEYS];
|
|
|
|
struct ieee80211_key __rcu *default_multicast_key;
|
|
|
|
struct ieee80211_key __rcu *default_mgmt_key;
|
|
|
|
struct ieee80211_key __rcu *default_beacon_key;
|
|
|
|
|
|
|
|
struct work_struct csa_finalize_work;
|
|
|
|
bool csa_block_tx; /* write-protected by sdata_lock and local->mtx */
|
2022-07-12 08:49:23 +00:00
|
|
|
|
|
|
|
bool operating_11g_mode;
|
|
|
|
|
2022-05-16 13:00:15 +00:00
|
|
|
struct cfg80211_chan_def csa_chandef;
|
|
|
|
|
|
|
|
struct work_struct color_change_finalize_work;
|
2023-01-25 11:01:02 +00:00
|
|
|
struct delayed_work color_collision_detect_work;
|
|
|
|
u64 color_bitmap;
|
2022-05-16 13:00:15 +00:00
|
|
|
|
|
|
|
/* context reservation -- protected with chanctx_mtx */
|
|
|
|
struct ieee80211_chanctx *reserved_chanctx;
|
|
|
|
struct cfg80211_chan_def reserved_chandef;
|
|
|
|
bool reserved_radar_required;
|
|
|
|
bool reserved_ready;
|
|
|
|
|
|
|
|
u8 needed_rx_chains;
|
|
|
|
enum ieee80211_smps_mode smps_mode;
|
|
|
|
|
|
|
|
int user_power_level; /* in dBm */
|
|
|
|
int ap_power_level; /* in dBm */
|
|
|
|
|
|
|
|
bool radar_required;
|
|
|
|
struct delayed_work dfs_cac_timer_work;
|
|
|
|
|
|
|
|
union {
|
|
|
|
struct ieee80211_link_data_managed mgd;
|
|
|
|
struct ieee80211_link_data_ap ap;
|
|
|
|
} u;
|
2022-06-17 20:36:37 +00:00
|
|
|
|
2022-06-24 13:40:11 +00:00
|
|
|
struct ieee80211_tx_queue_params tx_conf[IEEE80211_NUM_ACS];
|
|
|
|
|
2022-06-17 20:36:37 +00:00
|
|
|
struct ieee80211_bss_conf *conf;
|
2022-05-16 13:00:15 +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];
|
|
|
|
|
2021-05-11 18:02:47 +00:00
|
|
|
struct ieee80211_fragment_cache frags;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
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;
|
|
|
|
|
2022-05-16 13:00:15 +00:00
|
|
|
struct ieee80211_key __rcu *keys[NUM_DEFAULT_KEYS];
|
2011-05-13 12:15:49 +00:00
|
|
|
struct ieee80211_key __rcu *default_unicast_key;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2008-10-10 11:21:59 +00:00
|
|
|
u16 sequence_number;
|
2022-07-21 08:56:48 +00:00
|
|
|
u16 mld_mcast_seq;
|
2010-08-27 11:26:54 +00:00
|
|
|
__be16 control_port_protocol;
|
|
|
|
bool control_port_no_encrypt;
|
2020-03-12 09:10:54 +00:00
|
|
|
bool control_port_no_preauth;
|
2018-03-26 17:52:51 +00:00
|
|
|
bool control_port_over_nl80211;
|
2008-10-10 11:21:59 +00:00
|
|
|
|
2016-05-19 08:37:48 +00:00
|
|
|
atomic_t num_tx_queued;
|
2013-12-17 07:04:43 +00:00
|
|
|
struct mac80211_qos_map __rcu *qos_map;
|
2011-09-25 17:06:54 +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;
|
2021-08-23 18:02:39 +00:00
|
|
|
struct sk_buff_head status_queue;
|
2010-06-10 08:21:30 +00:00
|
|
|
|
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
|
|
|
|
2020-04-25 15:57:12 +00:00
|
|
|
/* Beacon frame (non-MCS) rate (as a bitmap) */
|
|
|
|
u32 beacon_rateidx_mask[NUM_NL80211_BANDS];
|
|
|
|
bool beacon_rate_set;
|
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
union {
|
|
|
|
struct ieee80211_if_ap ap;
|
|
|
|
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
|
|
|
|
2022-05-16 13:00:15 +00:00
|
|
|
struct ieee80211_link_data deflink;
|
2022-06-17 20:36:37 +00:00
|
|
|
struct ieee80211_link_data __rcu *link[IEEE80211_MLD_MAX_NUM_LINKS];
|
2022-05-16 13:00:15 +00:00
|
|
|
|
2022-09-02 14:12:56 +00:00
|
|
|
/* for ieee80211_set_active_links_async() */
|
|
|
|
struct work_struct activate_links_work;
|
|
|
|
u16 desired_active_links;
|
|
|
|
|
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;
|
2020-02-22 13:25:44 +00:00
|
|
|
struct dentry *default_beacon_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
|
2022-07-01 12:01:59 +00:00
|
|
|
ieee80211_chanwidth_get_shift(enum nl80211_chan_width width)
|
2013-07-08 14:55:51 +00:00
|
|
|
{
|
2022-07-01 12:01:59 +00:00
|
|
|
switch (width) {
|
2013-07-08 14:55:51 +00:00
|
|
|
case NL80211_CHAN_WIDTH_5:
|
|
|
|
return 2;
|
|
|
|
case NL80211_CHAN_WIDTH_10:
|
|
|
|
return 1;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-01 12:01:59 +00:00
|
|
|
static inline int
|
|
|
|
ieee80211_chandef_get_shift(struct cfg80211_chan_def *chandef)
|
|
|
|
{
|
|
|
|
return ieee80211_chanwidth_get_shift(chandef->width);
|
|
|
|
}
|
|
|
|
|
2013-07-08 14:55:51 +00:00
|
|
|
static inline int
|
|
|
|
ieee80211_vif_get_shift(struct ieee80211_vif *vif)
|
|
|
|
{
|
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
int shift = 0;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
wifi: mac80211: move some future per-link data to bss_conf
To add MLD, reuse the bss_conf structure later for per-link
information, so move some things into it that are per link.
Most transformations were done with the following spatch:
@@
expression sdata;
identifier var = { chanctx_conf, mu_mimo_owner, csa_active, color_change_active, color_change_color };
@@
-sdata->vif.var
+sdata->vif.bss_conf.var
@@
struct ieee80211_vif *vif;
identifier var = { chanctx_conf, mu_mimo_owner, csa_active, color_change_active, color_change_color };
@@
-vif->var
+vif->bss_conf.var
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-05-10 11:26:44 +00:00
|
|
|
chanctx_conf = rcu_dereference(vif->bss_conf.chanctx_conf);
|
2013-07-08 14:55:51 +00:00
|
|
|
if (chanctx_conf)
|
|
|
|
shift = ieee80211_chandef_get_shift(&chanctx_conf->def);
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return shift;
|
|
|
|
}
|
|
|
|
|
2022-02-24 11:54:58 +00:00
|
|
|
static inline int
|
|
|
|
ieee80211_get_mbssid_beacon_len(struct cfg80211_mbssid_elems *elems)
|
|
|
|
{
|
|
|
|
int i, len = 0;
|
|
|
|
|
|
|
|
if (!elems)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (i = 0; i < elems->cnt; i++)
|
|
|
|
len += elems->elem[i].len;
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
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;
|
2017-10-16 23:35:49 +00:00
|
|
|
struct ieee80211_local *local;
|
2010-11-30 07:58:45 +00:00
|
|
|
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.
|
2022-04-20 10:49:07 +00:00
|
|
|
* @SCAN_BEACON_WAIT: Set whenever we're passive scanning because of radar/no-IR
|
|
|
|
* and could send a probe request after receiving a beacon.
|
|
|
|
* @SCAN_BEACON_DONE: Beacon received, we can now send a probe request
|
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,
|
2022-04-20 10:49:07 +00:00
|
|
|
SCAN_BEACON_WAIT,
|
|
|
|
SCAN_BEACON_DONE,
|
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
|
|
|
};
|
|
|
|
|
2021-01-09 17:57:51 +00:00
|
|
|
DECLARE_STATIC_KEY_FALSE(aql_disable);
|
|
|
|
|
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
|
|
|
|
2018-12-19 01:02:06 +00:00
|
|
|
/* protects active_txqs and txqi->schedule_order */
|
2022-06-25 21:24:05 +00:00
|
|
|
spinlock_t active_txq_lock[IEEE80211_NUM_ACS];
|
|
|
|
struct list_head active_txqs[IEEE80211_NUM_ACS];
|
|
|
|
u16 schedule_round[IEEE80211_NUM_ACS];
|
|
|
|
|
2018-12-19 01:02:08 +00:00
|
|
|
u16 airtime_flags;
|
2022-06-25 21:24:05 +00:00
|
|
|
u32 aql_txq_limit_low[IEEE80211_NUM_ACS];
|
|
|
|
u32 aql_txq_limit_high[IEEE80211_NUM_ACS];
|
mac80211: Implement Airtime-based Queue Limit (AQL)
In order for the Fq_CoDel algorithm integrated in mac80211 layer to operate
effectively to control excessive queueing latency, the CoDel algorithm
requires an accurate measure of how long packets stays in the queue, AKA
sojourn time. The sojourn time measured at the mac80211 layer doesn't
include queueing latency in the lower layer (firmware/hardware) and CoDel
expects lower layer to have a short queue. However, most 802.11ac chipsets
offload tasks such TX aggregation to firmware or hardware, thus have a deep
lower layer queue.
Without a mechanism to control the lower layer queue size, packets only
stay in mac80211 layer transiently before being sent to firmware queue.
As a result, the sojourn time measured by CoDel in the mac80211 layer is
almost always lower than the CoDel latency target, hence CoDel does little
to control the latency, even when the lower layer queue causes excessive
latency.
The Byte Queue Limits (BQL) mechanism is commonly used to address the
similar issue with wired network interface. However, this method cannot be
applied directly to the wireless network interface. "Bytes" is not a
suitable measure of queue depth in the wireless network, as the data rate
can vary dramatically from station to station in the same network, from a
few Mbps to over Gbps.
This patch implements an Airtime-based Queue Limit (AQL) to make CoDel work
effectively with wireless drivers that utilized firmware/hardware
offloading. AQL allows each txq to release just enough packets to the lower
layer to form 1-2 large aggregations to keep hardware fully utilized and
retains the rest of the frames in mac80211 layer to be controlled by the
CoDel algorithm.
Signed-off-by: Kan Yan <kyan@google.com>
[ Toke: Keep API to set pending airtime internal, fix nits in commit msg ]
Signed-off-by: Toke Høiland-Jørgensen <toke@redhat.com>
Link: https://lore.kernel.org/r/20191119060610.76681-4-kyan@google.com
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2019-11-19 06:06:09 +00:00
|
|
|
u32 aql_threshold;
|
|
|
|
atomic_t aql_total_pending_airtime;
|
2022-06-25 21:24:09 +00:00
|
|
|
atomic_t aql_ac_pending_airtime[IEEE80211_NUM_ACS];
|
2018-12-19 01:02:08 +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;
|
2020-04-17 10:43:01 +00:00
|
|
|
bool probe_req_reg;
|
2020-04-21 14:48:15 +00:00
|
|
|
bool rx_mcast_action_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;
|
|
|
|
|
2021-10-21 08:45:27 +00:00
|
|
|
/* suspending is true during the whole suspend process */
|
|
|
|
bool suspending;
|
|
|
|
|
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;
|
|
|
|
|
2018-08-31 08:31:17 +00:00
|
|
|
/* bitmap of which sbands were copied */
|
|
|
|
u8 sband_allocated;
|
|
|
|
|
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;
|
2022-06-14 11:07:42 +00:00
|
|
|
struct rhltable link_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;
|
mac80211: add stop/start logic for software TXQs
Sometimes, it is required to stop the transmissions momentarily and
resume it later; stopping the txqs becomes very critical in scenarios where
the packet transmission has to be ceased completely. For example, during
the hardware restart, during off channel operations,
when initiating CSA(upon detecting a radar on the DFS channel), etc.
The TX queue stop/start logic in mac80211 works well in stopping the TX
when drivers make use of netdev queues, i.e, when Qdiscs in network layer
take care of traffic scheduling. Since the devices implementing
wake_tx_queue can run without Qdiscs, packets will be handed to mac80211
directly without queueing them in the netdev queues.
Also, mac80211 does not invoke any of the
netif_stop_*/netif_wake_* APIs if wake_tx_queue is implemented.
Since the queues are not stopped in this case, transmissions can continue
and this will impact negatively on the operation of the wireless device.
For example,
During hardware restart, we stop the netdev queues so that packets are
not sent to the driver. Since ath10k implements wake_tx_queue,
TX queues will not be stopped and packets might reach the hardware while
it is restarting; this can make hardware unresponsive and the only
possible option for recovery is to reboot the entire system.
There is another problem to this, it is observed that the packets
were sent on the DFS channel for a prolonged duration after radar
detection impacting the channel closing time.
We can still invoke netif stop/wake APIs when wake_tx_queue is implemented
but this could lead to packet drops in network layer; adding stop/start
logic for software TXQs in mac80211 instead makes more sense; the change
proposed adds the same in mac80211.
Signed-off-by: Manikanta Pubbisetty <mpubbise@codeaurora.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2018-07-10 18:42:53 +00:00
|
|
|
struct tasklet_struct wake_txqs_tasklet;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
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;
|
|
|
|
|
2019-06-12 16:19:54 +00:00
|
|
|
struct arc4_ctx wep_tx_ctx;
|
|
|
|
struct arc4_ctx wep_rx_ctx;
|
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
|
2019-03-19 20:34:08 +00:00
|
|
|
* key pointers and ptk_idx (write access, they're RCU.)
|
2008-04-11 19:40:35 +00:00
|
|
|
*/
|
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-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;
|
2019-03-28 20:01:06 +00:00
|
|
|
bool force_tx_status;
|
2007-05-05 18:46:38 +00:00
|
|
|
#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];
|
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 *
|
2021-11-12 11:22:23 +00:00
|
|
|
IEEE80211_DEV_TO_SUB_IF(const struct net_device *dev)
|
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
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2022-06-27 12:10:18 +00:00
|
|
|
WARN_ON(sdata->vif.valid_links);
|
|
|
|
|
2017-04-27 07:15:38 +00:00
|
|
|
rcu_read_lock();
|
wifi: mac80211: move some future per-link data to bss_conf
To add MLD, reuse the bss_conf structure later for per-link
information, so move some things into it that are per link.
Most transformations were done with the following spatch:
@@
expression sdata;
identifier var = { chanctx_conf, mu_mimo_owner, csa_active, color_change_active, color_change_color };
@@
-sdata->vif.var
+sdata->vif.bss_conf.var
@@
struct ieee80211_vif *vif;
identifier var = { chanctx_conf, mu_mimo_owner, csa_active, color_change_active, color_change_color };
@@
-vif->var
+vif->bss_conf.var
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-05-10 11:26:44 +00:00
|
|
|
chanctx_conf = rcu_dereference(sdata->vif.bss_conf.chanctx_conf);
|
2017-04-27 07:15:38 +00:00
|
|
|
|
2021-05-17 14:47:17 +00:00
|
|
|
if (!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];
|
|
|
|
}
|
|
|
|
|
2022-06-19 12:08:02 +00:00
|
|
|
static inline struct ieee80211_supported_band *
|
2022-06-17 20:36:37 +00:00
|
|
|
ieee80211_get_link_sband(struct ieee80211_link_data *link)
|
2022-06-19 12:08:02 +00:00
|
|
|
{
|
2022-06-17 20:36:37 +00:00
|
|
|
struct ieee80211_local *local = link->sdata->local;
|
2022-06-19 12:08:02 +00:00
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
enum nl80211_band band;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
2022-06-17 20:36:37 +00:00
|
|
|
chanctx_conf = rcu_dereference(link->conf->chanctx_conf);
|
2022-06-19 12:08:02 +00:00
|
|
|
if (!chanctx_conf) {
|
|
|
|
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;
|
2019-02-06 11:17:09 +00:00
|
|
|
u32 max_switch_time;
|
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;
|
2021-09-20 13:40:08 +00:00
|
|
|
u32 crc;
|
2011-11-18 15:54:50 +00:00
|
|
|
|
|
|
|
/* 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 *rsn;
|
2020-01-31 11:12:57 +00:00
|
|
|
const u8 *rsnx;
|
2013-02-12 15:43:19 +00:00
|
|
|
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;
|
2018-06-09 06:14:44 +00:00
|
|
|
const u8 *he_cap;
|
|
|
|
const struct ieee80211_he_operation *he_operation;
|
2019-06-18 06:19:14 +00:00
|
|
|
const struct ieee80211_he_spr *he_spr;
|
2018-06-09 06:14:44 +00:00
|
|
|
const struct ieee80211_mu_edca_param_set *mu_edca_param_set;
|
2020-05-28 19:34:30 +00:00
|
|
|
const struct ieee80211_he_6ghz_capa *he_6ghz_capa;
|
2021-08-20 12:20:40 +00:00
|
|
|
const struct ieee80211_tx_pwr_env *tx_pwr_env[IEEE80211_TPE_MAX_IE_COUNT];
|
2018-06-09 06:14:44 +00:00
|
|
|
const u8 *uora_element;
|
2013-02-12 15:43:19 +00:00
|
|
|
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;
|
2019-02-06 11:17:09 +00:00
|
|
|
const u8 *max_channel_switch_time;
|
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;
|
2019-01-16 16:22:56 +00:00
|
|
|
const struct ieee80211_multiple_bssid_configuration *mbssid_config_ie;
|
|
|
|
const struct ieee80211_bssid_index *bssid_index;
|
|
|
|
u8 max_bssid_indicator;
|
|
|
|
u8 dtim_count;
|
|
|
|
u8 dtim_period;
|
2019-07-13 16:36:41 +00:00
|
|
|
const struct ieee80211_addba_ext_ie *addba_ext_ie;
|
2020-09-22 02:28:08 +00:00
|
|
|
const struct ieee80211_s1g_cap *s1g_capab;
|
|
|
|
const struct ieee80211_s1g_oper_ie *s1g_oper;
|
|
|
|
const struct ieee80211_s1g_bcn_compat_ie *s1g_bcn_compat;
|
2020-09-22 02:28:15 +00:00
|
|
|
const struct ieee80211_aid_response_ie *aid_resp;
|
2022-02-14 16:29:59 +00:00
|
|
|
const struct ieee80211_eht_cap_elem *eht_cap;
|
|
|
|
const struct ieee80211_eht_operation *eht_operation;
|
2022-06-30 11:48:22 +00:00
|
|
|
const struct ieee80211_multi_link_elem *multi_link;
|
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 rsn_len;
|
2020-01-31 11:12:57 +00:00
|
|
|
u8 rsnx_len;
|
2011-11-18 15:54:50 +00:00
|
|
|
u8 ext_supp_rates_len;
|
|
|
|
u8 wmm_info_len;
|
|
|
|
u8 wmm_param_len;
|
2018-06-09 06:14:44 +00:00
|
|
|
u8 he_cap_len;
|
2011-11-18 15:54:50 +00:00
|
|
|
u8 mesh_id_len;
|
|
|
|
u8 peering_len;
|
|
|
|
u8 preq_len;
|
|
|
|
u8 prep_len;
|
|
|
|
u8 perr_len;
|
|
|
|
u8 country_elem_len;
|
2019-01-16 16:22:56 +00:00
|
|
|
u8 bssid_index_len;
|
2021-08-20 12:20:40 +00:00
|
|
|
u8 tx_pwr_env_len[IEEE80211_TPE_MAX_IE_COUNT];
|
|
|
|
u8 tx_pwr_env_num;
|
2022-02-14 16:29:59 +00:00
|
|
|
u8 eht_cap_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
|
|
|
|
2022-09-06 08:48:56 +00:00
|
|
|
/* mult-link element can be de-fragmented and thus u8 is not sufficient */
|
|
|
|
size_t multi_link_len;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* store the per station profile pointer and length in case that the
|
|
|
|
* parsing also handled Multi-Link element parsing for a specific link
|
|
|
|
* ID.
|
|
|
|
*/
|
|
|
|
struct ieee80211_mle_per_sta_profile *prof;
|
|
|
|
size_t sta_prof_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;
|
2022-09-06 08:48:56 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* scratch buffer that can be used for various element parsing related
|
|
|
|
* tasks, e.g., element de-fragmentation etc.
|
|
|
|
*/
|
|
|
|
size_t scratch_len;
|
|
|
|
u8 *scratch_pos;
|
|
|
|
u8 scratch[];
|
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);
|
|
|
|
}
|
|
|
|
|
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);
|
2020-12-06 12:54:45 +00:00
|
|
|
return !!(status->flag & (RX_FLAG_MACTIME_START | RX_FLAG_MACTIME_END |
|
|
|
|
RX_FLAG_MACTIME_PLCP_START));
|
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,
|
2022-05-24 08:55:56 +00:00
|
|
|
u64 changed);
|
|
|
|
void ieee80211_vif_cfg_change_notify(struct ieee80211_sub_if_data *sdata,
|
|
|
|
u64 changed);
|
|
|
|
void ieee80211_link_info_change_notify(struct ieee80211_sub_if_data *sdata,
|
2022-06-17 20:36:37 +00:00
|
|
|
struct ieee80211_link_data *link,
|
|
|
|
u64 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);
|
|
|
|
|
2022-06-30 13:43:44 +00:00
|
|
|
bool ieee80211_is_our_addr(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *addr, int *out_link_id);
|
|
|
|
|
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);
|
2020-09-22 02:28:14 +00:00
|
|
|
void ieee80211_sta_rx_queued_ext(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);
|
2021-04-09 09:40:14 +00:00
|
|
|
void ieee80211_sta_connection_lost(struct ieee80211_sub_if_data *sdata,
|
2022-05-13 15:46:23 +00:00
|
|
|
u8 reason, bool tx);
|
2022-06-24 08:57:41 +00:00
|
|
|
void ieee80211_mgd_setup_link(struct ieee80211_link_data *link);
|
|
|
|
void ieee80211_mgd_stop_link(struct ieee80211_link_data *link);
|
2022-09-02 14:12:46 +00:00
|
|
|
void ieee80211_mgd_set_link_qos_params(struct ieee80211_link_data *link);
|
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,
|
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
|
|
|
|
2021-07-02 17:44:08 +00:00
|
|
|
/* color change handling */
|
|
|
|
void ieee80211_color_change_finalize_work(struct work_struct *work);
|
2023-01-25 11:01:02 +00:00
|
|
|
void ieee80211_color_collision_detection_work(struct work_struct *work);
|
2021-07-02 17:44:08 +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 */
|
2020-01-31 11:12:46 +00:00
|
|
|
#define MAC80211_SUPPORTED_FEATURES_TX (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | \
|
|
|
|
NETIF_F_HW_CSUM | NETIF_F_SG | \
|
|
|
|
NETIF_F_HIGHDMA | NETIF_F_GSO_SOFTWARE)
|
|
|
|
#define MAC80211_SUPPORTED_FEATURES_RX (NETIF_F_RXCSUM)
|
|
|
|
#define MAC80211_SUPPORTED_FEATURES (MAC80211_SUPPORTED_FEATURES_TX | \
|
|
|
|
MAC80211_SUPPORTED_FEATURES_RX)
|
|
|
|
|
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);
|
2020-09-08 12:36:53 +00:00
|
|
|
void ieee80211_recalc_offload(struct ieee80211_local *local);
|
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
|
|
|
}
|
|
|
|
|
2022-09-02 14:12:37 +00:00
|
|
|
/* link handling */
|
|
|
|
void ieee80211_link_setup(struct ieee80211_link_data *link);
|
|
|
|
void ieee80211_link_init(struct ieee80211_sub_if_data *sdata,
|
|
|
|
int link_id,
|
|
|
|
struct ieee80211_link_data *link,
|
|
|
|
struct ieee80211_bss_conf *link_conf);
|
|
|
|
void ieee80211_link_stop(struct ieee80211_link_data *link);
|
|
|
|
int ieee80211_vif_set_links(struct ieee80211_sub_if_data *sdata,
|
|
|
|
u16 new_links);
|
|
|
|
void ieee80211_vif_clear_links(struct ieee80211_sub_if_data *sdata);
|
|
|
|
|
2007-07-27 13:43:22 +00:00
|
|
|
/* tx handling */
|
|
|
|
void ieee80211_clear_tx_pending(struct ieee80211_local *local);
|
2020-11-03 09:18:18 +00:00
|
|
|
void ieee80211_tx_pending(struct tasklet_struct *t);
|
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);
|
2019-11-25 10:04:37 +00:00
|
|
|
netdev_tx_t ieee80211_subif_start_xmit_8023(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,
|
2019-04-11 20:47:25 +00:00
|
|
|
u32 info_flags,
|
2020-05-27 16:03:34 +00:00
|
|
|
u32 ctrl_flags,
|
|
|
|
u64 *cookie);
|
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,
|
2019-07-14 15:44:15 +00:00
|
|
|
int retry_count, int shift, bool send_to_cooked,
|
|
|
|
struct ieee80211_tx_status *status);
|
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);
|
2018-03-26 17:52:50 +00:00
|
|
|
int ieee80211_tx_control_port(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
const u8 *buf, size_t len,
|
2020-05-08 14:42:00 +00:00
|
|
|
const u8 *dest, __be16 proto, bool unencrypted,
|
2022-06-30 12:27:59 +00:00
|
|
|
int link_id, u64 *cookie);
|
2019-04-11 20:47:26 +00:00
|
|
|
int ieee80211_probe_mesh_link(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
const u8 *buf, size_t len);
|
2015-03-21 14:25:43 +00:00
|
|
|
|
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,
|
2022-06-15 07:20:45 +00:00
|
|
|
struct link_sta_info *link_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
|
|
|
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);
|
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,
|
2019-07-29 10:45:12 +00:00
|
|
|
u16 buf_size, bool tx, bool auto_seq,
|
|
|
|
const struct ieee80211_addba_ext_ie *addbaext);
|
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);
|
2018-03-27 13:46:16 +00:00
|
|
|
enum nl80211_smps_mode
|
|
|
|
ieee80211_smps_mode_to_smps_mode(enum ieee80211_smps_mode smps);
|
2012-09-11 12:34:12 +00:00
|
|
|
|
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,
|
2022-06-15 07:20:45 +00:00
|
|
|
struct link_sta_info *link_sta);
|
|
|
|
enum ieee80211_sta_rx_bandwidth
|
|
|
|
ieee80211_sta_cap_rx_bw(struct link_sta_info *link_sta);
|
|
|
|
enum ieee80211_sta_rx_bandwidth
|
|
|
|
ieee80211_sta_cur_vht_bw(struct link_sta_info *link_sta);
|
|
|
|
void ieee80211_sta_set_rx_nss(struct link_sta_info *link_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);
|
2022-06-15 07:20:45 +00:00
|
|
|
enum nl80211_chan_width
|
|
|
|
ieee80211_sta_cap_chan_bw(struct link_sta_info *link_sta);
|
2015-12-08 14:04:31 +00:00
|
|
|
void ieee80211_process_mu_groups(struct ieee80211_sub_if_data *sdata,
|
2022-06-17 20:36:37 +00:00
|
|
|
struct ieee80211_link_data *link,
|
2015-12-08 14:04:31 +00:00
|
|
|
struct ieee80211_mgmt *mgmt);
|
2014-02-03 13:44:44 +00:00
|
|
|
u32 __ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
|
2022-06-15 07:20:45 +00:00
|
|
|
struct link_sta_info *sta,
|
2022-05-30 21:22:19 +00:00
|
|
|
u8 opmode, enum nl80211_band band);
|
2012-12-27 17:55:36 +00:00
|
|
|
void ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
|
2022-06-15 07:20:45 +00:00
|
|
|
struct link_sta_info *sta,
|
2022-05-30 21:22:19 +00:00
|
|
|
u8 opmode, 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]);
|
2018-03-27 13:46:17 +00:00
|
|
|
enum nl80211_chan_width
|
2022-06-15 07:20:45 +00:00
|
|
|
ieee80211_sta_rx_bw_to_chan_width(struct link_sta_info *sta);
|
2013-02-07 10:58:58 +00:00
|
|
|
|
2018-06-09 06:14:44 +00:00
|
|
|
/* HE */
|
|
|
|
void
|
|
|
|
ieee80211_he_cap_ie_to_sta_he_cap(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_supported_band *sband,
|
|
|
|
const u8 *he_cap_ie, u8 he_cap_len,
|
2020-05-28 19:34:38 +00:00
|
|
|
const struct ieee80211_he_6ghz_capa *he_6ghz_capa,
|
2022-06-15 07:20:45 +00:00
|
|
|
struct link_sta_info *link_sta);
|
2019-07-30 16:37:01 +00:00
|
|
|
void
|
|
|
|
ieee80211_he_spr_ie_to_bss_conf(struct ieee80211_vif *vif,
|
|
|
|
const struct ieee80211_he_spr *he_spr_ie_elem);
|
2018-06-09 06:14:44 +00:00
|
|
|
|
2019-07-29 10:23:42 +00:00
|
|
|
void
|
|
|
|
ieee80211_he_op_ie_to_bss_conf(struct ieee80211_vif *vif,
|
|
|
|
const struct ieee80211_he_operation *he_op_ie_elem);
|
|
|
|
|
2020-10-05 16:45:22 +00:00
|
|
|
/* S1G */
|
|
|
|
void ieee80211_s1g_sta_rate_init(struct sta_info *sta);
|
2021-08-23 18:02:39 +00:00
|
|
|
bool ieee80211_s1g_is_twt_setup(struct sk_buff *skb);
|
|
|
|
void ieee80211_s1g_rx_twt_action(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb);
|
|
|
|
void ieee80211_s1g_status_twt_action(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb);
|
2020-10-05 16:45:22 +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
|
2020-05-28 19:34:35 +00:00
|
|
|
* @vht_cap_info: VHT capabilities of the transmitter
|
2022-06-23 10:04:55 +00:00
|
|
|
* @conn_flags: contains information about own capabilities and restrictions
|
|
|
|
* to decide which channel switch announcements can be accepted, using
|
|
|
|
* flags from &enum ieee80211_conn_flags.
|
2013-08-28 11:41:29 +00:00
|
|
|
* @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,
|
2020-05-28 19:34:35 +00:00
|
|
|
u32 vht_cap_info,
|
2022-06-23 10:04:55 +00:00
|
|
|
ieee80211_conn_flags_t conn_flags, u8 *bssid,
|
2013-10-15 02:08:29 +00:00
|
|
|
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);
|
2018-03-28 10:24:10 +00:00
|
|
|
void ieee80211_regulatory_limit_wmm_params(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_tx_queue_params *qparam,
|
|
|
|
int ac);
|
2022-06-24 13:40:11 +00:00
|
|
|
void ieee80211_set_wmm_default(struct ieee80211_link_data *link,
|
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,
|
2020-07-23 10:01:52 +00:00
|
|
|
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,
|
2022-07-18 19:36:08 +00:00
|
|
|
struct sk_buff *skb, int tid, int link_id,
|
2020-07-23 10:01:52 +00:00
|
|
|
enum nl80211_band band);
|
2012-07-26 15:24:39 +00:00
|
|
|
|
2019-11-25 10:04:37 +00:00
|
|
|
/* sta_out needs to be checked for ERR_PTR() before using */
|
|
|
|
int ieee80211_lookup_ra_sta(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb,
|
|
|
|
struct sta_info **sta_out);
|
|
|
|
|
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,
|
2020-07-23 10:01:52 +00:00
|
|
|
enum nl80211_band band)
|
2012-07-26 15:24:39 +00:00
|
|
|
{
|
|
|
|
rcu_read_lock();
|
2022-07-18 19:36:08 +00:00
|
|
|
__ieee80211_tx_skb_tid_band(sdata, skb, tid, -1, band);
|
2012-07-26 15:24:39 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
2011-12-15 09:18:34 +00:00
|
|
|
|
2022-06-01 13:59:31 +00:00
|
|
|
void ieee80211_tx_skb_tid(struct ieee80211_sub_if_data *sdata,
|
2022-07-18 19:36:08 +00:00
|
|
|
struct sk_buff *skb, int tid, int link_id);
|
2012-07-26 15:24:39 +00:00
|
|
|
|
|
|
|
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. */
|
2022-07-18 19:36:08 +00:00
|
|
|
ieee80211_tx_skb_tid(sdata, skb, 7, -1);
|
2011-12-15 09:18:34 +00:00
|
|
|
}
|
|
|
|
|
2022-06-28 15:49:12 +00:00
|
|
|
/**
|
|
|
|
* struct ieee80211_elems_parse_params - element parsing parameters
|
|
|
|
* @start: pointer to the elements
|
|
|
|
* @len: length of the elements
|
|
|
|
* @action: %true if the elements came from an action frame
|
|
|
|
* @filter: bitmap of element IDs to filter out while calculating
|
|
|
|
* the element CRC
|
|
|
|
* @crc: CRC starting value
|
2022-06-29 11:29:05 +00:00
|
|
|
* @bss: the BSS to parse this as, for multi-BSSID cases this can
|
|
|
|
* represent a non-transmitting BSS in which case the data
|
|
|
|
* for that non-transmitting BSS is returned
|
2022-06-30 11:48:22 +00:00
|
|
|
* @link_id: the link ID to parse elements for, if a STA profile
|
2022-09-06 08:48:56 +00:00
|
|
|
* is present in the multi-link element, or -1 to ignore;
|
|
|
|
* note that the code currently assumes parsing an association
|
|
|
|
* (or re-association) response frame if this is given
|
2022-08-16 09:26:23 +00:00
|
|
|
* @from_ap: frame is received from an AP (currently used only
|
|
|
|
* for EHT capabilities parsing)
|
2022-09-06 08:48:56 +00:00
|
|
|
* @scratch_len: if non zero, specifies the requested length of the scratch
|
|
|
|
* buffer; otherwise, 'len' is used.
|
2022-06-28 15:49:12 +00:00
|
|
|
*/
|
|
|
|
struct ieee80211_elems_parse_params {
|
|
|
|
const u8 *start;
|
|
|
|
size_t len;
|
|
|
|
bool action;
|
|
|
|
u64 filter;
|
|
|
|
u32 crc;
|
2022-06-29 11:29:05 +00:00
|
|
|
struct cfg80211_bss *bss;
|
2022-06-30 11:48:22 +00:00
|
|
|
int link_id;
|
2022-08-16 09:26:23 +00:00
|
|
|
bool from_ap;
|
2022-09-06 08:48:56 +00:00
|
|
|
size_t scratch_len;
|
2022-06-28 15:49:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ieee802_11_elems *
|
|
|
|
ieee802_11_parse_elems_full(struct ieee80211_elems_parse_params *params);
|
|
|
|
|
|
|
|
static inline struct ieee802_11_elems *
|
|
|
|
ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
|
|
|
|
u64 filter, u32 crc,
|
2022-06-29 11:29:05 +00:00
|
|
|
struct cfg80211_bss *bss)
|
2022-06-28 15:49:12 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_elems_parse_params params = {
|
|
|
|
.start = start,
|
|
|
|
.len = len,
|
|
|
|
.action = action,
|
|
|
|
.filter = filter,
|
|
|
|
.crc = crc,
|
2022-06-29 11:29:05 +00:00
|
|
|
.bss = bss,
|
2022-06-30 11:48:22 +00:00
|
|
|
.link_id = -1,
|
2022-06-28 15:49:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
return ieee802_11_parse_elems_full(¶ms);
|
|
|
|
}
|
|
|
|
|
mac80211: always allocate struct ieee802_11_elems
As the 802.11 spec evolves, we need to parse more and more
elements. This is causing the struct to grow, and we can no
longer get away with putting it on the stack.
Change the API to always dynamically allocate and return an
allocated pointer that must be kfree()d later.
As an alternative, I contemplated a scheme whereby we'd say
in the code which elements we needed, e.g.
DECLARE_ELEMENT_PARSER(elems,
SUPPORTED_CHANNELS,
CHANNEL_SWITCH,
EXT(KEY_DELIVERY));
ieee802_11_parse_elems(..., &elems, ...);
and while I think this is possible and will save us a lot
since most individual places only care about a small subset
of the elements, it ended up being a bit more work since a
lot of places do the parsing and then pass the struct to
other functions, sometimes with multiple levels.
Link: https://lore.kernel.org/r/20210920154009.26caff6b5998.I05ae58768e990e611aee8eca8abefd9d7bc15e05@changeid
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2021-09-20 13:40:10 +00:00
|
|
|
static inline struct ieee802_11_elems *
|
|
|
|
ieee802_11_parse_elems(const u8 *start, size_t len, bool action,
|
2022-06-29 11:29:05 +00:00
|
|
|
struct cfg80211_bss *bss)
|
2013-03-27 13:55:31 +00:00
|
|
|
{
|
2022-06-29 11:29:05 +00:00
|
|
|
return ieee802_11_parse_elems_crc(start, len, action, 0, 0, bss);
|
2013-03-27 13:55:31 +00:00
|
|
|
}
|
|
|
|
|
2022-07-07 13:28:14 +00:00
|
|
|
void ieee80211_fragment_element(struct sk_buff *skb, u8 *len_pos);
|
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);
|
2017-10-16 23:35:49 +00:00
|
|
|
void ieee80211_dynamic_ps_timer(struct timer_list *t);
|
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);
|
2021-07-02 05:01:11 +00:00
|
|
|
void ieee80211_send_4addr_nullfunc(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata);
|
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);
|
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)
|
|
|
|
{
|
2019-05-29 12:25:30 +00:00
|
|
|
/*
|
|
|
|
* It's unsafe to try to do any work during reconfigure flow.
|
|
|
|
* When the flow ends the work will be requeued.
|
|
|
|
*/
|
|
|
|
if (local->in_reconfig)
|
|
|
|
return false;
|
|
|
|
|
2015-01-22 21:32:46 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
2018-05-08 11:03:50 +00:00
|
|
|
void ieee80211_txq_set_params(struct ieee80211_local *local);
|
2016-05-19 08:37:49 +00:00
|
|
|
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);
|
2017-10-06 09:53:33 +00:00
|
|
|
void ieee80211_txq_remove_vlan(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata);
|
2018-05-08 11:03:50 +00:00
|
|
|
void ieee80211_fill_txq_stats(struct cfg80211_txq_stats *txqstats,
|
|
|
|
struct txq_info *txqi);
|
2020-11-03 09:18:18 +00:00
|
|
|
void ieee80211_wake_txqs(struct tasklet_struct *t);
|
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,
|
2019-08-30 11:24:51 +00:00
|
|
|
const u8 *da, const u8 *bssid,
|
|
|
|
u16 stype, u16 reason,
|
2012-09-07 11:28:52 +00:00
|
|
|
bool send_frame, u8 *frame_buf);
|
2018-05-28 13:47:38 +00:00
|
|
|
|
|
|
|
enum {
|
|
|
|
IEEE80211_PROBE_FLAG_DIRECTED = BIT(0),
|
2018-05-28 13:47:41 +00:00
|
|
|
IEEE80211_PROBE_FLAG_MIN_CONTENT = BIT(1),
|
|
|
|
IEEE80211_PROBE_FLAG_RANDOM_SN = BIT(2),
|
2018-05-28 13:47:38 +00:00
|
|
|
};
|
|
|
|
|
2020-05-28 19:34:39 +00:00
|
|
|
int ieee80211_build_preq_ies(struct ieee80211_sub_if_data *sdata, 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,
|
2018-05-28 13:47:38 +00:00
|
|
|
struct cfg80211_chan_def *chandef,
|
|
|
|
u32 flags);
|
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,
|
2018-05-28 13:47:38 +00:00
|
|
|
u32 flags);
|
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,
|
2022-06-17 20:36:37 +00:00
|
|
|
struct ieee80211_link_data *link,
|
2013-10-01 13:45:43 +00:00
|
|
|
enum ieee80211_smps_mode smps_mode);
|
2022-05-30 21:45:04 +00:00
|
|
|
void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata,
|
2022-06-17 20:36:37 +00:00
|
|
|
struct ieee80211_link_data *link);
|
2022-06-22 13:15:56 +00:00
|
|
|
void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata,
|
|
|
|
int link_id);
|
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);
|
2019-07-24 16:33:56 +00:00
|
|
|
u8 ieee80211_ie_len_he_cap(struct ieee80211_sub_if_data *sdata, u8 iftype);
|
2022-06-23 10:04:55 +00:00
|
|
|
u8 *ieee80211_ie_build_he_cap(ieee80211_conn_flags_t disable_flags, u8 *pos,
|
2018-06-09 06:14:44 +00:00
|
|
|
const struct ieee80211_sta_he_cap *he_cap,
|
|
|
|
u8 *end);
|
2020-05-28 19:34:32 +00:00
|
|
|
void ieee80211_ie_build_he_6ghz_cap(struct ieee80211_sub_if_data *sdata,
|
2022-08-25 18:57:32 +00:00
|
|
|
enum ieee80211_smps_mode smps_mode,
|
2020-05-28 19:34:32 +00:00
|
|
|
struct sk_buff *skb);
|
2020-05-28 19:34:33 +00:00
|
|
|
u8 *ieee80211_ie_build_he_oper(u8 *pos, struct cfg80211_chan_def *chandef);
|
2022-07-01 12:01:59 +00:00
|
|
|
int ieee80211_parse_bitrates(enum nl80211_chan_width width,
|
2013-07-08 14:55:53 +00:00
|
|
|
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);
|
2020-09-22 02:28:05 +00:00
|
|
|
void ieee80211_add_s1g_capab_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_sta_s1g_cap *caps,
|
|
|
|
struct sk_buff *skb);
|
2020-09-22 02:28:15 +00:00
|
|
|
void ieee80211_add_aid_request_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb);
|
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);
|
2020-05-28 19:34:35 +00:00
|
|
|
bool ieee80211_chandef_vht_oper(struct ieee80211_hw *hw, u32 vht_cap_info,
|
2018-08-31 08:31:18 +00:00
|
|
|
const struct ieee80211_vht_operation *oper,
|
|
|
|
const struct ieee80211_ht_operation *htop,
|
2015-12-18 14:08:34 +00:00
|
|
|
struct cfg80211_chan_def *chandef);
|
2022-09-02 14:12:34 +00:00
|
|
|
void ieee80211_chandef_eht_oper(const struct ieee80211_eht_operation *eht_oper,
|
2022-04-27 15:02:10 +00:00
|
|
|
bool support_160, bool support_320,
|
|
|
|
struct cfg80211_chan_def *chandef);
|
2020-05-28 19:34:36 +00:00
|
|
|
bool ieee80211_chandef_he_6ghz_oper(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const struct ieee80211_he_operation *he_oper,
|
2022-02-14 16:30:00 +00:00
|
|
|
const struct ieee80211_eht_operation *eht_oper,
|
2020-05-28 19:34:36 +00:00
|
|
|
struct cfg80211_chan_def *chandef);
|
2020-09-22 02:28:15 +00:00
|
|
|
bool ieee80211_chandef_s1g_oper(const struct ieee80211_s1g_oper_ie *oper,
|
|
|
|
struct cfg80211_chan_def *chandef);
|
2022-06-23 10:04:55 +00:00
|
|
|
ieee80211_conn_flags_t 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
|
2022-05-30 16:35:23 +00:00
|
|
|
ieee80211_link_use_channel(struct ieee80211_link_data *link,
|
|
|
|
const struct cfg80211_chan_def *chandef,
|
|
|
|
enum ieee80211_chanctx_mode mode);
|
2013-10-30 11:09:39 +00:00
|
|
|
int __must_check
|
2022-05-30 16:35:23 +00:00
|
|
|
ieee80211_link_reserve_chanctx(struct ieee80211_link_data *link,
|
|
|
|
const struct cfg80211_chan_def *chandef,
|
|
|
|
enum ieee80211_chanctx_mode mode,
|
|
|
|
bool radar_required);
|
2013-10-30 11:09:39 +00:00
|
|
|
int __must_check
|
2022-05-30 16:35:23 +00:00
|
|
|
ieee80211_link_use_reserved_context(struct ieee80211_link_data *link);
|
|
|
|
int ieee80211_link_unreserve_chanctx(struct ieee80211_link_data *link);
|
2013-10-30 11:09:39 +00:00
|
|
|
|
2013-02-07 20:37:29 +00:00
|
|
|
int __must_check
|
2022-05-30 16:35:23 +00:00
|
|
|
ieee80211_link_change_bandwidth(struct ieee80211_link_data *link,
|
|
|
|
const struct cfg80211_chan_def *chandef,
|
2023-01-27 11:39:31 +00:00
|
|
|
u64 *changed);
|
2022-05-30 16:35:23 +00:00
|
|
|
void ieee80211_link_release_channel(struct ieee80211_link_data *link);
|
|
|
|
void ieee80211_link_vlan_copy_chanctx(struct ieee80211_link_data *link);
|
|
|
|
void ieee80211_link_copy_chanctx_to_vlans(struct ieee80211_link_data *link,
|
|
|
|
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-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
|
|
|
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);
|
mac80211: handle deauthentication/disassociation from TDLS peer
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>
2019-05-10 09:04:52 +00:00
|
|
|
void ieee80211_tdls_handle_disconnect(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *peer, u16 reason);
|
2021-05-17 21:07:56 +00:00
|
|
|
void
|
|
|
|
ieee80211_process_tdls_channel_switch(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb);
|
|
|
|
|
|
|
|
|
mac80211: handle deauthentication/disassociation from TDLS peer
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>
2019-05-10 09:04:52 +00:00
|
|
|
const char *ieee80211_get_reason_code_string(u16 reason_code);
|
2020-09-22 02:28:10 +00:00
|
|
|
u16 ieee80211_encode_usf(int val);
|
2020-09-22 02:28:14 +00:00
|
|
|
u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
|
|
|
|
enum nl80211_iftype type);
|
2014-05-01 07:17:28 +00:00
|
|
|
|
2014-06-04 15:31:56 +00:00
|
|
|
extern const struct ethtool_ops ieee80211_ethtool_ops;
|
|
|
|
|
2019-11-19 06:06:08 +00:00
|
|
|
u32 ieee80211_calc_expected_tx_airtime(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
struct ieee80211_sta *pubsta,
|
2020-07-24 18:28:16 +00:00
|
|
|
int len, bool ampdu);
|
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
|
|
|
|
|
2021-05-11 18:02:47 +00:00
|
|
|
void ieee80211_init_frag_cache(struct ieee80211_fragment_cache *cache);
|
|
|
|
void ieee80211_destroy_frag_cache(struct ieee80211_fragment_cache *cache);
|
|
|
|
|
2022-02-14 16:30:01 +00:00
|
|
|
u8 ieee80211_ie_len_eht_cap(struct ieee80211_sub_if_data *sdata, u8 iftype);
|
|
|
|
u8 *ieee80211_ie_build_eht_cap(u8 *pos,
|
|
|
|
const struct ieee80211_sta_he_cap *he_cap,
|
|
|
|
const struct ieee80211_sta_eht_cap *eht_cap,
|
2022-08-16 09:26:23 +00:00
|
|
|
u8 *end,
|
|
|
|
bool for_ap);
|
2022-02-14 16:30:02 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
ieee80211_eht_cap_ie_to_sta_eht_cap(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_supported_band *sband,
|
|
|
|
const u8 *he_cap_ie, u8 he_cap_len,
|
|
|
|
const struct ieee80211_eht_cap_elem *eht_cap_ie_elem,
|
2022-06-15 07:20:45 +00:00
|
|
|
u8 eht_cap_len,
|
|
|
|
struct link_sta_info *link_sta);
|
2007-05-05 18:45:53 +00:00
|
|
|
#endif /* IEEE80211_I_H */
|