ieee80211_i.h 68.3 KB
Newer Older
1 2 3 4
/*
 * Copyright 2002-2005, Instant802 Networks, Inc.
 * Copyright 2005, Devicescape Software, Inc.
 * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
5
 * Copyright 2007-2010	Johannes Berg <johannes@sipsolutions.net>
6
 * Copyright 2013-2015  Intel Mobile Communications GmbH
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#ifndef IEEE80211_I_H
#define IEEE80211_I_H

#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/if_ether.h>
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/workqueue.h>
#include <linux/types.h>
#include <linux/spinlock.h>
26
#include <linux/etherdevice.h>
27
#include <linux/leds.h>
J
Johannes Berg 已提交
28
#include <linux/idr.h>
29
#include <linux/rhashtable.h>
J
Johannes Berg 已提交
30
#include <net/ieee80211_radiotap.h>
31
#include <net/cfg80211.h>
32
#include <net/mac80211.h>
33
#include <net/fq.h>
J
Johannes Berg 已提交
34
#include "key.h"
35
#include "sta_info.h"
J
Johannes Berg 已提交
36
#include "debug.h"
37

J
Johannes Berg 已提交
38 39
extern const struct cfg80211_ops mac80211_config_ops;

40
struct ieee80211_local;
41 42 43 44 45 46 47 48 49 50 51 52

/* 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
53
#define IEEE80211_ENCRYPT_TAILROOM 18
54 55 56 57 58 59 60

/* IEEE 802.11 (Ch. 9.5 Defragmentation) requires support for concurrent
 * reception of at least three fragmented frames. This limit can be increased
 * by changing this define, at the cost of slower frame reassembly and
 * increased memory use (about 2 kB of RAM per entry). */
#define IEEE80211_FRAGMENT_MAX 4

61 62 63
/* power level hasn't been configured (or set to automatic) */
#define IEEE80211_UNSET_POWER_LEVEL	INT_MIN

64
/*
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
 * 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.
81
 */
82
#define IEEE80211_DEFAULT_UAPSD_QUEUES 0
K
Kalle Valo 已提交
83 84 85 86

#define IEEE80211_DEFAULT_MAX_SP_LEN		\
	IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL

87 88
extern const u8 ieee80211_ac_to_qos_mask[IEEE80211_NUM_ACS];

89 90
#define IEEE80211_DEAUTH_FRAME_LEN	(24 /* hdr */ + 2 /* reason */)

91 92
#define IEEE80211_MAX_NAN_INSTANCE_ID 255

93 94
struct ieee80211_fragment_entry {
	struct sk_buff_head skb_list;
95 96 97 98 99
	unsigned long first_frag_time;
	u16 seq;
	u16 extra_len;
	u16 last_frag;
	u8 rx_queue;
100
	bool check_sequential_pn; /* needed for CCMP/GCMP */
101 102 103 104
	u8 last_pn[6]; /* PN of the last fragment if CCMP was used */
};


105
struct ieee80211_bss {
106
	u32 device_ts_beacon, device_ts_presp;
107

108
	bool wmm_used;
K
Kalle Valo 已提交
109
	bool uapsd_supported;
110

111 112 113
#define IEEE80211_MAX_SUPP_RATES 32
	u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
	size_t supp_rates_len;
114
	struct ieee80211_rate *beacon_rate;
115

116
	/*
L
Lucas De Marchi 已提交
117
	 * During association, we save an ERP value from a probe response so
118 119
	 * that we can feed ERP info to the driver when handling the
	 * association completes. these fields probably won't be up-to-date
120 121 122
	 * otherwise, you probably don't want to use them.
	 */
	bool has_erp_value;
123
	u8 erp_value;
P
Paul Stewart 已提交
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152

	/* 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
S
Stephen Hemminger 已提交
153
 * of the data structure were received as a result of an un-corrupted
P
Paul Stewart 已提交
154 155 156 157 158 159
 * 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)
160 161
};

162
typedef unsigned __bitwise ieee80211_tx_result;
163 164 165 166
#define TX_CONTINUE	((__force ieee80211_tx_result) 0u)
#define TX_DROP		((__force ieee80211_tx_result) 1u)
#define TX_QUEUED	((__force ieee80211_tx_result) 2u)

167 168 169 170 171
#define IEEE80211_TX_UNICAST		BIT(1)
#define IEEE80211_TX_PS_BUFFERED	BIT(2)

struct ieee80211_tx_data {
	struct sk_buff *skb;
172
	struct sk_buff_head skbs;
173 174 175 176
	struct ieee80211_local *local;
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;
	struct ieee80211_key *key;
177
	struct ieee80211_tx_rate rate;
178

179
	unsigned int flags;
180 181 182
};


183
typedef unsigned __bitwise ieee80211_rx_result;
J
Johannes Berg 已提交
184 185 186 187
#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)
188

189 190 191 192
/**
 * enum ieee80211_packet_rx_flags - packet RX flags
 * @IEEE80211_RX_AMSDU: a-MSDU packet
 * @IEEE80211_RX_MALFORMED_ACTION_FRM: action frame is malformed
193
 * @IEEE80211_RX_DEFERRED_RELEASE: frame was subjected to receive reordering
194 195 196 197 198 199 200
 *
 * 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),
201
	IEEE80211_RX_DEFERRED_RELEASE		= BIT(5),
202 203 204 205 206 207
};

/**
 * enum ieee80211_rx_flags - RX data flags
 *
 * @IEEE80211_RX_CMNTR: received on cooked monitor already
J
Johannes Berg 已提交
208 209
 * @IEEE80211_RX_BEACON_REPORTED: This frame was already reported
 *	to cfg80211_report_obss_beacon().
210 211 212 213 214 215
 *
 * These flags are used across handling multiple interfaces
 * for a single frame.
 */
enum ieee80211_rx_flags {
	IEEE80211_RX_CMNTR		= BIT(0),
J
Johannes Berg 已提交
216
	IEEE80211_RX_BEACON_REPORTED	= BIT(1),
217
};
218 219

struct ieee80211_rx_data {
220
	struct napi_struct *napi;
221 222 223 224 225
	struct sk_buff *skb;
	struct ieee80211_local *local;
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;
	struct ieee80211_key *key;
226 227

	unsigned int flags;
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243

	/*
	 * 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;

244 245
	u32 tkip_iv32;
	u16 tkip_iv16;
246 247
};

248 249 250 251 252 253 254 255 256 257
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;
};

258 259 260
struct beacon_data {
	u8 *head, *tail;
	int head_len, tail_len;
261
	struct ieee80211_meshconf_ie *meshconf;
262 263
	u16 csa_counter_offsets[IEEE80211_MAX_CSA_COUNTERS_NUM];
	u8 csa_current_counter;
264
	struct rcu_head rcu_head;
265 266
};

267 268 269
struct probe_resp {
	struct rcu_head rcu_head;
	int len;
270
	u16 csa_counter_offsets[IEEE80211_MAX_CSA_COUNTERS_NUM];
271 272 273
	u8 data[0];
};

274
struct ps_data {
275 276
	/* yes, this looks ugly, but guarantees that we can later use
	 * bitmap_empty :)
277
	 * NB: don't touch this bitmap, use sta_info_{set,clear}_tim_bit */
278 279
	u8 tim[sizeof(unsigned long) * BITS_TO_LONGS(IEEE80211_MAX_AID + 1)]
			__aligned(__alignof__(unsigned long));
280
	struct sk_buff_head bc_buf;
281
	atomic_t num_sta_ps; /* number of stations in PS mode */
282
	int dtim_count;
283
	bool dtim_bc_mc;
284 285
};

286 287 288 289
struct ieee80211_if_ap {
	struct beacon_data __rcu *beacon;
	struct probe_resp __rcu *probe_resp;

290 291
	/* to be used after channel switch. */
	struct cfg80211_beacon_data *next_beacon;
292
	struct list_head vlans; /* write-protected with RTNL and local->mtx */
293 294 295

	struct ps_data ps;
	atomic_t num_mcast_sta; /* number of stations receiving multicast */
296 297 298 299
	enum ieee80211_smps_mode req_smps, /* requested smps mode */
			 driver_smps_mode; /* smps mode request */

	struct work_struct request_smps_work;
300
	bool multicast_to_unicast;
301 302
};

303 304
struct ieee80211_if_wds {
	struct sta_info *sta;
305
	u8 remote_addr[ETH_ALEN];
306 307 308
};

struct ieee80211_if_vlan {
309
	struct list_head list; /* write-protected with RTNL and local->mtx */
310 311

	/* used for all tx if the VLAN is configured to 4-addr mode */
J
Johannes Berg 已提交
312
	struct sta_info __rcu *sta;
313
	atomic_t num_mcast_sta; /* number of stations receiving multicast */
314 315
};

316
struct mesh_stats {
317 318 319
	__u32 fwded_mcast;		/* Mesh forwarded multicast frames */
	__u32 fwded_unicast;		/* Mesh forwarded unicast frames */
	__u32 fwded_frames;		/* Mesh total forwarded frames */
320 321
	__u32 dropped_frames_ttl;	/* Not transmitted since mesh_ttl == 0*/
	__u32 dropped_frames_no_route;	/* Not transmitted, no route found */
322
	__u32 dropped_frames_congestion;/* Not forwarded due to congestion */
323 324 325 326 327 328 329 330 331 332
};

#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;
};

333
struct ieee80211_roc_work {
334
	struct list_head list;
J
Johannes Berg 已提交
335 336 337

	struct ieee80211_sub_if_data *sdata;

338
	struct ieee80211_channel *chan;
J
Johannes Berg 已提交
339

340
	bool started, abort, hw_begun, notified;
341
	bool on_channel;
342

343
	unsigned long start_time;
344

345 346
	u32 duration, req_duration;
	struct sk_buff *frame;
347
	u64 cookie, mgmt_tx_cookie;
348
	enum ieee80211_roc_type type;
349 350
};

351
/* flags used in struct ieee80211_if_managed.flags */
352
enum ieee80211_sta_flags {
J
Johannes Berg 已提交
353 354
	IEEE80211_STA_CONNECTION_POLL	= BIT(1),
	IEEE80211_STA_CONTROL_PORT	= BIT(2),
355
	IEEE80211_STA_DISABLE_HT	= BIT(4),
J
Johannes Berg 已提交
356
	IEEE80211_STA_MFP_ENABLED	= BIT(6),
K
Kalle Valo 已提交
357
	IEEE80211_STA_UAPSD_ENABLED	= BIT(7),
358
	IEEE80211_STA_NULLFUNC_ACKED	= BIT(8),
359
	IEEE80211_STA_RESET_SIGNAL_AVE	= BIT(9),
360
	IEEE80211_STA_DISABLE_40MHZ	= BIT(10),
361
	IEEE80211_STA_DISABLE_VHT	= BIT(11),
J
Johannes Berg 已提交
362 363
	IEEE80211_STA_DISABLE_80P80MHZ	= BIT(12),
	IEEE80211_STA_DISABLE_160MHZ	= BIT(13),
364
	IEEE80211_STA_DISABLE_WMM	= BIT(14),
365
	IEEE80211_STA_ENABLE_RRM	= BIT(15),
366 367
};

J
Johannes Berg 已提交
368 369 370 371 372 373 374 375 376
struct ieee80211_mgd_auth_data {
	struct cfg80211_bss *bss;
	unsigned long timeout;
	int tries;
	u16 algorithm, expected_transaction;

	u8 key[WLAN_KEY_LEN_WEP104];
	u8 key_len, key_idx;
	bool done;
377
	bool timeout_started;
J
Johannes Berg 已提交
378

379 380 381
	u16 sae_trans, sae_status;
	size_t data_len;
	u8 data[];
J
Johannes Berg 已提交
382 383 384 385 386 387 388 389 390 391 392 393 394 395
};

struct ieee80211_mgd_assoc_data {
	struct cfg80211_bss *bss;
	const u8 *supp_rates;

	unsigned long timeout;
	int tries;

	u16 capability;
	u8 prev_bssid[ETH_ALEN];
	u8 ssid[IEEE80211_MAX_SSID_LEN];
	u8 ssid_len;
	u8 supp_rates_len;
396
	bool wmm, uapsd;
397
	bool need_beacon;
J
Johannes Berg 已提交
398
	bool synced;
399
	bool timeout_started;
J
Johannes Berg 已提交
400

401 402
	u8 ap_ht_param;

403 404
	struct ieee80211_vht_cap ap_vht_cap;

405 406 407 408
	u8 fils_nonces[2 * FILS_NONCE_LEN];
	u8 fils_kek[FILS_MAX_KEK_LEN];
	size_t fils_kek_len;

J
Johannes Berg 已提交
409 410 411 412
	size_t ie_len;
	u8 ie[];
};

413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430
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;
};

431
DECLARE_EWMA(beacon_signal, 4, 4)
432

433
struct ieee80211_if_managed {
434
	struct timer_list timer;
J
Johannes Berg 已提交
435 436
	struct timer_list conn_mon_timer;
	struct timer_list bcn_mon_timer;
S
Sujith 已提交
437
	struct timer_list chswitch_timer;
J
Johannes Berg 已提交
438
	struct work_struct monitor_work;
S
Sujith 已提交
439
	struct work_struct chswitch_work;
440
	struct work_struct beacon_connection_loss_work;
441
	struct work_struct csa_connection_drop_work;
442

443
	unsigned long beacon_timeout;
J
Johannes Berg 已提交
444
	unsigned long probe_timeout;
445
	int probe_send_count;
446
	bool nullfunc_failed;
447
	bool connection_loss;
J
Johannes Berg 已提交
448

449
	struct cfg80211_bss *associated;
J
Johannes Berg 已提交
450 451
	struct ieee80211_mgd_auth_data *auth_data;
	struct ieee80211_mgd_assoc_data *assoc_data;
452

M
Michael Braun 已提交
453
	u8 bssid[ETH_ALEN] __aligned(2);
454

455 456
	u16 aid;

457
	bool powersave; /* powersave requested for this iface */
458
	bool broken_ap; /* AP is broken -- turn off powersave */
459
	bool have_beacon;
460
	u8 dtim_period;
461
	enum ieee80211_smps_mode req_smps, /* requested smps mode */
462 463 464
				 driver_smps_mode; /* smps mode request */

	struct work_struct request_smps_work;
465

466
	unsigned int flags;
467

468
	bool csa_waiting_bcn;
469
	bool csa_ignored_same_chan;
470

471
	bool beacon_crc_valid;
472 473
	u32 beacon_crc;

474 475 476 477
	bool status_acked;
	bool status_received;
	__le16 status_fc;

478 479 480 481 482 483
	enum {
		IEEE80211_MFP_DISABLED,
		IEEE80211_MFP_OPTIONAL,
		IEEE80211_MFP_REQUIRED
	} mfp; /* management frame protection */

484 485 486 487 488 489 490 491 492 493 494 495 496 497
	/*
	 * 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;

498
	int wmm_last_param_set;
499 500

	u8 use_4addr;
501

J
Janusz Dziedzic 已提交
502
	s16 p2p_noa_index;
503

504
	struct ewma_beacon_signal ave_beacon_signal;
505

506 507 508 509 510 511 512
	/*
	 * 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;

513 514 515
	/* Number of times beacon loss was invoked. */
	unsigned int beacon_loss_count;

516 517 518 519 520 521
	/*
	 * 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;
522 523 524 525 526 527 528 529

	/*
	 * State variables for keeping track of RSSI of the AP currently
	 * connected to and informing driver when RSSI has gone
	 * below/above a certain threshold.
	 */
	int rssi_min_thold, rssi_max_thold;
	int last_ave_beacon_signal;
B
Ben Greear 已提交
530 531 532

	struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
	struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */
533 534
	struct ieee80211_vht_cap vht_capa; /* configured VHT overrides */
	struct ieee80211_vht_cap vht_capa_mask; /* Valid parts of vht_capa */
535

536
	/* TDLS support */
537 538
	u8 tdls_peer[ETH_ALEN] __aligned(2);
	struct delayed_work tdls_peer_del_work;
539 540 541
	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 */
542
	bool tdls_chan_switch_prohibited;
543
	bool tdls_wider_bw_prohibited;
544 545 546 547 548 549 550 551 552 553

	/* 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;
554 555
};

556 557
struct ieee80211_if_ibss {
	struct timer_list timer;
558
	struct work_struct csa_connection_drop_work;
559

560
	unsigned long last_scan_completed;
561

562 563
	u32 basic_rates;

564 565
	bool fixed_bssid;
	bool fixed_channel;
J
Johannes Berg 已提交
566
	bool privacy;
567

568
	bool control_port;
569
	bool userspace_handles_dfs;
570

571
	u8 bssid[ETH_ALEN] __aligned(2);
572 573 574
	u8 ssid[IEEE80211_MAX_SSID_LEN];
	u8 ssid_len, ie_len;
	u8 *ie;
575
	struct cfg80211_chan_def chandef;
576 577

	unsigned long ibss_join_req;
578
	/* probe response/beacon for IBSS */
579
	struct beacon_data __rcu *presp;
580

581 582 583
	struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
	struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */

584 585 586
	spinlock_t incomplete_lock;
	struct list_head incomplete_stations;

587 588 589 590 591 592
	enum {
		IEEE80211_IBSS_MLME_SEARCH,
		IEEE80211_IBSS_MLME_JOINED,
	} state;
};

593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
/**
 * 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;
};

612 613 614 615 616 617 618 619 620 621 622 623 624 625
/**
 * struct ieee80211_mesh_sync_ops - Extensible synchronization framework interface
 *
 * these declarations define the interface, which enables
 * vendor-specific mesh synchronization
 *
 */
struct ieee802_11_elems;
struct ieee80211_mesh_sync_ops {
	void (*rx_bcn_presp)(struct ieee80211_sub_if_data *sdata,
			     u16 stype,
			     struct ieee80211_mgmt *mgmt,
			     struct ieee802_11_elems *elems,
			     struct ieee80211_rx_status *rx_status);
626 627

	/* should be called with beacon_data under RCU read lock */
628 629
	void (*adjust_tsf)(struct ieee80211_sub_if_data *sdata,
			   struct beacon_data *beacon);
630 631 632
	/* add other framework functions here */
};

633 634 635 636 637
struct mesh_csa_settings {
	struct rcu_head rcu_head;
	struct cfg80211_csa_settings settings;
};

638 639 640
struct ieee80211_if_mesh {
	struct timer_list housekeeping_timer;
	struct timer_list mesh_path_timer;
641
	struct timer_list mesh_path_root_timer;
642

643
	unsigned long wrkq_flags;
644
	unsigned long mbss_changed;
645 646 647 648

	u8 mesh_id[IEEE80211_MAX_MESH_ID_LEN];
	size_t mesh_id_len;
	/* Active Path Selection Protocol Identifier */
R
Rui Paulo 已提交
649
	u8 mesh_pp_id;
650
	/* Active Path Selection Metric Identifier */
R
Rui Paulo 已提交
651
	u8 mesh_pm_id;
652
	/* Congestion Control Mode Identifier */
R
Rui Paulo 已提交
653
	u8 mesh_cc_id;
654
	/* Synchronization Protocol Identifier */
R
Rui Paulo 已提交
655
	u8 mesh_sp_id;
656
	/* Authentication Protocol Identifier */
R
Rui Paulo 已提交
657
	u8 mesh_auth_id;
658 659
	/* Local mesh Sequence Number */
	u32 sn;
660 661 662
	/* Last used PREQ ID */
	u32 preq_id;
	atomic_t mpaths;
663 664
	/* Timestamp of last SN update */
	unsigned long last_sn_update;
665 666 667
	/* Time when it's ok to send next PERR */
	unsigned long next_perr;
	/* Timestamp of last PREQ sent */
668 669 670 671 672 673 674
	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;
675
	atomic_t estab_plinks;
676 677
	u32 mesh_seqnum;
	bool accepting_plinks;
678
	int num_gates;
T
Thomas Pedersen 已提交
679
	struct beacon_data __rcu *beacon;
680 681
	const u8 *ie;
	u8 ie_len;
682 683 684 685 686
	enum {
		IEEE80211_MESH_SEC_NONE = 0x0,
		IEEE80211_MESH_SEC_AUTHED = 0x1,
		IEEE80211_MESH_SEC_SECURED = 0x2,
	} security;
687
	bool user_mpm;
688
	/* Extensible Synchronization Framework */
689
	const struct ieee80211_mesh_sync_ops *sync_ops;
690 691
	s64 sync_offset_clockdrift_max;
	spinlock_t sync_offset_lock;
M
Marco Porsch 已提交
692 693 694 695 696
	/* mesh power save */
	enum nl80211_mesh_power_mode nonpeer_pm;
	int ps_peers_light_sleep;
	int ps_peers_deep_sleep;
	struct ps_data ps;
697
	/* Channel Switching Support */
698
	struct mesh_csa_settings __rcu *csa;
699 700 701 702 703
	enum {
		IEEE80211_MESH_CSA_ROLE_NONE,
		IEEE80211_MESH_CSA_ROLE_INIT,
		IEEE80211_MESH_CSA_ROLE_REPEATER,
	} csa_role;
704
	u8 chsw_ttl;
705
	u16 pre_value;
706 707 708

	/* offset from skb->data while building IE */
	int meshconf_offset;
709

710 711
	struct mesh_table *mesh_paths;
	struct mesh_table *mpp_paths; /* Store paths for MPP&MAP */
712 713
	int mesh_paths_generation;
	int mpp_paths_generation;
714
};
J
Johannes Berg 已提交
715 716

#ifdef CONFIG_MAC80211_MESH
717 718
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name)	\
	do { (msh)->mshstats.name++; } while (0)
J
Johannes Berg 已提交
719
#else
720
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \
J
Johannes Berg 已提交
721 722
	do { } while (0)
#endif
723

724 725 726 727 728 729 730 731
/**
 * enum ieee80211_sub_if_data_flags - virtual interface flags
 *
 * @IEEE80211_SDATA_ALLMULTI: interface wants all multicast packets
 * @IEEE80211_SDATA_OPERATING_GMODE: operating in G-only mode
 * @IEEE80211_SDATA_DONT_BRIDGE_PACKETS: bridge packets between
 *	associated stations and deliver multicast frames both
 *	back to wireless media and to the local net stack.
732
 * @IEEE80211_SDATA_DISCONNECT_RESUME: Disconnect after resume.
733
 * @IEEE80211_SDATA_IN_DRIVER: indicates interface was added to driver
734 735 736
 */
enum ieee80211_sub_if_data_flags {
	IEEE80211_SDATA_ALLMULTI		= BIT(0),
737 738
	IEEE80211_SDATA_OPERATING_GMODE		= BIT(2),
	IEEE80211_SDATA_DONT_BRIDGE_PACKETS	= BIT(3),
739
	IEEE80211_SDATA_DISCONNECT_RESUME	= BIT(4),
740
	IEEE80211_SDATA_IN_DRIVER		= BIT(5),
741 742
};

743 744 745 746 747
/**
 * 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
748 749
 * @SDATA_STATE_OFFCHANNEL: This interface is currently in offchannel
 *	mode, so queues are stopped
750 751
 * @SDATA_STATE_OFFCHANNEL_BEACON_STOPPED: Beaconing was stopped due
 *	to offchannel, reset when offchannel returns
752 753 754
 */
enum ieee80211_sdata_state_bits {
	SDATA_STATE_RUNNING,
755
	SDATA_STATE_OFFCHANNEL,
756
	SDATA_STATE_OFFCHANNEL_BEACON_STOPPED,
757 758
};

759 760 761 762 763 764 765 766 767 768 769 770 771 772
/**
 * 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
};

773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790
/**
 * 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,
};

791 792 793 794
struct ieee80211_chanctx {
	struct list_head list;
	struct rcu_head rcu_head;

795
	struct list_head assigned_vifs;
796
	struct list_head reserved_vifs;
797

798 799 800
	enum ieee80211_chanctx_replace_state replace_state;
	struct ieee80211_chanctx *replace_ctx;

801
	enum ieee80211_chanctx_mode mode;
802
	bool driver_present;
803 804 805 806

	struct ieee80211_chanctx_conf conf;
};

807 808 809 810 811
struct mac80211_qos_map {
	struct cfg80211_qos_map qos_map;
	struct rcu_head rcu_head;
};

812 813 814
enum txq_info_flags {
	IEEE80211_TXQ_STOP,
	IEEE80211_TXQ_AMPDU,
F
Felix Fietkau 已提交
815
	IEEE80211_TXQ_NO_AMSDU,
816 817
};

818 819 820 821 822 823
/**
 * 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
824
 * @def_cvars: codel vars for @def_flow
825
 * @frags: used to keep fragments created after dequeue
826
 */
827
struct txq_info {
828 829
	struct fq_tin tin;
	struct fq_flow def_flow;
830
	struct codel_vars def_cvars;
831
	struct codel_stats cstats;
832
	struct sk_buff_head frags;
833 834 835 836 837 838
	unsigned long flags;

	/* keep last! */
	struct ieee80211_txq txq;
};

839 840
struct ieee80211_if_mntr {
	u32 flags;
841
	u8 mu_follow_addr[ETH_ALEN] __aligned(2);
842 843

	struct list_head list;
844 845
};

846 847 848 849
/**
 * struct ieee80211_if_nan - NAN state
 *
 * @conf: current NAN configuration
850
 * @func_ids: a bitmap of available instance_id's
851 852 853
 */
struct ieee80211_if_nan {
	struct cfg80211_nan_conf conf;
854 855 856 857

	/* protects function_inst_ids */
	spinlock_t func_lock;
	struct idr function_inst_ids;
858 859
};

860 861 862 863 864
struct ieee80211_sub_if_data {
	struct list_head list;

	struct wireless_dev wdev;

J
Johannes Berg 已提交
865 866 867
	/* keys */
	struct list_head key_list;

868 869
	/* count for keys needing tailroom space allocation */
	int crypto_tx_tailroom_needed_cnt;
870 871
	int crypto_tx_tailroom_pending_dec;
	struct delayed_work dec_tailroom_needed_wk;
872

873 874 875
	struct net_device *dev;
	struct ieee80211_local *local;

876
	unsigned int flags;
877

878 879
	unsigned long state;

880 881
	char name[IFNAMSIZ];

882 883 884 885
	/* Fragment table for host-based reassembly */
	struct ieee80211_fragment_entry	fragments[IEEE80211_FRAGMENT_MAX];
	unsigned int fragment_next;

886 887 888
	/* TID bitmap for NoAck policy */
	u16 noack_map;

Y
Yoni Divinsky 已提交
889 890 891
	/* bit field of ACM bits (BIT(802.1D tag)) */
	u8 wmm_acm;

J
Johannes Berg 已提交
892 893 894 895
	struct ieee80211_key __rcu *keys[NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS];
	struct ieee80211_key __rcu *default_unicast_key;
	struct ieee80211_key __rcu *default_multicast_key;
	struct ieee80211_key __rcu *default_mgmt_key;
896

J
Johannes Berg 已提交
897
	u16 sequence_number;
898 899
	__be16 control_port_protocol;
	bool control_port_no_encrypt;
900
	int encrypt_headroom;
J
Johannes Berg 已提交
901

902
	atomic_t num_tx_queued;
903
	struct ieee80211_tx_queue_params tx_conf[IEEE80211_NUM_ACS];
904
	struct mac80211_qos_map __rcu *qos_map;
905

906
	struct work_struct csa_finalize_work;
907
	bool csa_block_tx; /* write-protected by sdata_lock and local->mtx */
908
	struct cfg80211_chan_def csa_chandef;
909

910
	struct list_head assigned_chanctx_list; /* protected by chanctx_mtx */
911
	struct list_head reserved_chanctx_list; /* protected by chanctx_mtx */
912

913 914 915
	/* context reservation -- protected with chanctx_mtx */
	struct ieee80211_chanctx *reserved_chanctx;
	struct cfg80211_chan_def reserved_chandef;
916
	bool reserved_radar_required;
917
	bool reserved_ready;
918

919 920 921
	/* used to reconfigure hardware SM PS */
	struct work_struct recalc_smps;

J
Johannes Berg 已提交
922
	struct work_struct work;
J
Johannes Berg 已提交
923 924
	struct sk_buff_head skb_queue;

925 926 927
	u8 needed_rx_chains;
	enum ieee80211_smps_mode smps_mode;

928 929 930
	int user_power_level; /* in dBm */
	int ap_power_level; /* in dBm */

931 932 933
	bool radar_required;
	struct delayed_work dfs_cac_timer_work;

934
	/*
935 936 937
	 * AP this belongs to: self in AP mode and
	 * corresponding AP in VLAN mode, NULL for
	 * all others (might be needed later in IBSS)
938
	 */
939 940
	struct ieee80211_if_ap *bss;

941
	/* bitmap of allowed (non-MCS) rate indexes for rate control */
942
	u32 rc_rateidx_mask[NUM_NL80211_BANDS];
943

944 945
	bool rc_has_mcs_mask[NUM_NL80211_BANDS];
	u8  rc_rateidx_mcs_mask[NUM_NL80211_BANDS][IEEE80211_HT_MCS_MASK_LEN];
946

947 948
	bool rc_has_vht_mcs_mask[NUM_NL80211_BANDS];
	u16 rc_rateidx_vht_mcs_mask[NUM_NL80211_BANDS][NL80211_VHT_NSS_MAX];
949

950 951 952 953
	union {
		struct ieee80211_if_ap ap;
		struct ieee80211_if_wds wds;
		struct ieee80211_if_vlan vlan;
954 955
		struct ieee80211_if_managed mgd;
		struct ieee80211_if_ibss ibss;
956
		struct ieee80211_if_mesh mesh;
957
		struct ieee80211_if_ocb ocb;
958
		struct ieee80211_if_mntr mntr;
959
		struct ieee80211_if_nan nan;
960
	} u;
J
Jiri Benc 已提交
961 962

#ifdef CONFIG_MAC80211_DEBUGFS
963
	struct {
964
		struct dentry *subdir_stations;
965 966
		struct dentry *default_unicast_key;
		struct dentry *default_multicast_key;
967
		struct dentry *default_mgmt_key;
968
	} debugfs;
J
Jiri Benc 已提交
969
#endif
970

971 972
	/* must be last, dynamically sized area in this! */
	struct ieee80211_vif vif;
973 974
};

975 976 977 978 979 980
static inline
struct ieee80211_sub_if_data *vif_to_sdata(struct ieee80211_vif *p)
{
	return container_of(p, struct ieee80211_sub_if_data, vif);
}

981 982 983 984 985 986 987 988 989 990 991 992 993 994
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);
}

995 996 997
#define sdata_dereference(p, sdata) \
	rcu_dereference_protected(p, lockdep_is_held(&sdata->wdev.mtx))

998 999 1000 1001 1002 1003
static inline void
sdata_assert_lock(struct ieee80211_sub_if_data *sdata)
{
	lockdep_assert_held(&sdata->wdev.mtx);
}

1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
static inline int
ieee80211_chandef_get_shift(struct cfg80211_chan_def *chandef)
{
	switch (chandef->width) {
	case NL80211_CHAN_WIDTH_5:
		return 2;
	case NL80211_CHAN_WIDTH_10:
		return 1;
	default:
		return 0;
	}
}

static inline int
ieee80211_vif_get_shift(struct ieee80211_vif *vif)
{
	struct ieee80211_chanctx_conf *chanctx_conf;
	int shift = 0;

	rcu_read_lock();
	chanctx_conf = rcu_dereference(vif->chanctx_conf);
	if (chanctx_conf)
		shift = ieee80211_chandef_get_shift(&chanctx_conf->def);
	rcu_read_unlock();

	return shift;
}

1032 1033 1034 1035 1036
struct ieee80211_rx_agg {
	u8 addr[ETH_ALEN];
	u16 tid;
};

1037 1038 1039 1040
enum sdata_queue_type {
	IEEE80211_SDATA_QUEUE_TYPE_FRAME	= 0,
	IEEE80211_SDATA_QUEUE_AGG_START		= 1,
	IEEE80211_SDATA_QUEUE_AGG_STOP		= 2,
1041 1042
	IEEE80211_SDATA_QUEUE_RX_AGG_START	= 3,
	IEEE80211_SDATA_QUEUE_RX_AGG_STOP	= 4,
1043 1044
};

1045 1046 1047 1048 1049
enum {
	IEEE80211_RX_MSG	= 1,
	IEEE80211_TX_STATUS_MSG	= 2,
};

K
Kalle Valo 已提交
1050 1051
enum queue_stop_reason {
	IEEE80211_QUEUE_STOP_REASON_DRIVER,
1052
	IEEE80211_QUEUE_STOP_REASON_PS,
1053 1054
	IEEE80211_QUEUE_STOP_REASON_CSA,
	IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
1055
	IEEE80211_QUEUE_STOP_REASON_SUSPEND,
1056
	IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
1057
	IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL,
1058
	IEEE80211_QUEUE_STOP_REASON_FLUSH,
1059
	IEEE80211_QUEUE_STOP_REASON_TDLS_TEARDOWN,
1060
	IEEE80211_QUEUE_STOP_REASON_RESERVE_TID,
1061 1062

	IEEE80211_QUEUE_STOP_REASONS,
K
Kalle Valo 已提交
1063 1064
};

1065
#ifdef CONFIG_MAC80211_LEDS
1066 1067 1068 1069 1070 1071 1072
struct tpt_led_trigger {
	char name[32];
	const struct ieee80211_tpt_blink *blink_table;
	unsigned int blink_table_len;
	struct timer_list timer;
	unsigned long prev_traffic;
	unsigned long tx_bytes, rx_bytes;
1073 1074
	unsigned int active, want;
	bool running;
1075
};
1076
#endif
1077

1078 1079 1080 1081 1082 1083 1084
/**
 * 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
1085 1086
 * @SCAN_ONCHANNEL_SCANNING:  Do a software scan on only the current operating
 *	channel. This should not interrupt normal traffic.
1087 1088 1089 1090
 * @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.
1091 1092
 * @SCAN_HW_CANCELLED: Set for our scan work function when the scan is being
 *	cancelled.
1093
 */
1094 1095
enum {
	SCAN_SW_SCANNING,
1096
	SCAN_HW_SCANNING,
1097
	SCAN_ONCHANNEL_SCANNING,
1098 1099
	SCAN_COMPLETED,
	SCAN_ABORTED,
1100
	SCAN_HW_CANCELLED,
1101 1102 1103 1104 1105 1106 1107 1108 1109 1110
};

/**
 * 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
1111 1112 1113
 * @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
1114
 * @SCAN_ABORT: Abort the scan and go back to operating channel
1115 1116 1117 1118 1119
 */
enum mac80211_scan_state {
	SCAN_DECISION,
	SCAN_SET_CHANNEL,
	SCAN_SEND_PROBE,
1120 1121
	SCAN_SUSPEND,
	SCAN_RESUME,
1122
	SCAN_ABORT,
1123 1124
};

1125 1126 1127 1128 1129 1130
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;

1131
	struct fq fq;
1132 1133
	struct codel_vars *cvars;
	struct codel_params cparams;
1134

1135 1136
	const struct ieee80211_ops *ops;

1137 1138 1139 1140 1141 1142
	/*
	 * private workqueue to mac80211. mac80211 makes this accessible
	 * via ieee80211_queue_work()
	 */
	struct workqueue_struct *workqueue;

1143
	unsigned long queue_stop_reasons[IEEE80211_MAX_QUEUES];
1144
	int q_stop_reasons[IEEE80211_MAX_QUEUES][IEEE80211_QUEUE_STOP_REASONS];
1145
	/* also used to protect ampdu_ac_queue and amdpu_ac_stop_refcnt */
K
Kalle Valo 已提交
1146
	spinlock_t queue_stop_reason_lock;
1147

1148
	int open_count;
1149
	int monitors, cooked_mntrs;
1150
	/* number of interfaces with corresponding FIF_ flags */
1151 1152 1153
	int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss, fif_pspoll,
	    fif_probe_req;
	int probe_req_reg;
1154
	unsigned int filter_flags; /* FIF_* */
J
Johannes Berg 已提交
1155

1156 1157
	bool wiphy_ciphers_allocated;

1158 1159
	bool use_chanctx;

J
Johannes Berg 已提交
1160 1161 1162
	/* protects the aggregated multicast list and filter calls */
	spinlock_t filter_lock;

1163 1164 1165
	/* used for uploading changed mc list */
	struct work_struct reconfig_filter;

J
Johannes Berg 已提交
1166
	/* aggregated multicast list */
1167
	struct netdev_hw_addr_list mc_list;
J
Johannes Berg 已提交
1168

1169
	bool tim_in_locked_section; /* see ieee80211_beacon_get() */
1170 1171 1172 1173 1174 1175 1176 1177 1178

	/*
	 * 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;

J
Johannes Berg 已提交
1179 1180 1181 1182 1183 1184 1185 1186
	/*
	 * 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;

1187 1188 1189 1190 1191 1192
	/*
	 * quiescing is true during the suspend process _only_ to
	 * ease timer cancelling etc.
	 */
	bool quiescing;

1193 1194 1195
	/* device is started */
	bool started;

1196 1197 1198
	/* device is during a HW reconfig */
	bool in_reconfig;

1199 1200 1201
	/* wowlan is enabled -- don't reconfig on resume */
	bool wowlan;

1202 1203
	struct work_struct radar_detected_work;

1204 1205 1206
	/* number of RX chains the hardware has */
	u8 rx_chains;

1207
	int tx_headroom; /* required headroom for hardware/radiotap */
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217

	/* 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;

1218
	spinlock_t rx_path_lock;
1219

1220 1221
	/* Station data */
	/*
1222 1223
	 * The mutex only protects the list, hash table and
	 * counter, reads are done with RCU.
1224
	 */
1225
	struct mutex sta_mtx;
1226
	spinlock_t tim_lock;
1227
	unsigned long num_sta;
1228
	struct list_head sta_list;
1229
	struct rhltable sta_hash;
1230
	struct timer_list sta_cleanup;
1231
	int sta_generation;
1232

1233
	struct sk_buff_head pending[IEEE80211_MAX_QUEUES];
1234 1235
	struct tasklet_struct tx_pending_tasklet;

1236
	atomic_t agg_queue_stop[IEEE80211_MAX_QUEUES];
1237

1238 1239
	/* number of interfaces with allmulti RX */
	atomic_t iff_allmultis;
1240 1241 1242

	struct rate_control_ref *rate_ctrl;

1243 1244
	struct crypto_cipher *wep_tx_tfm;
	struct crypto_cipher *wep_rx_tfm;
1245 1246
	u32 wep_iv;

1247
	/* see iface.c */
1248
	struct list_head interfaces;
1249
	struct list_head mon_list; /* only that are IFF_UP && !cooked */
1250
	struct mutex iflist_mtx;
1251

J
Johannes Berg 已提交
1252
	/*
J
Johannes Berg 已提交
1253
	 * Key mutex, protects sdata's key_list and sta_info's
J
Johannes Berg 已提交
1254 1255
	 * key pointers (write access, they're RCU.)
	 */
J
Johannes Berg 已提交
1256
	struct mutex key_mtx;
J
Johannes Berg 已提交
1257

1258 1259
	/* mutex for scan and work locking */
	struct mutex mtx;
J
Johannes Berg 已提交
1260

1261
	/* Scanning and BSS list */
1262
	unsigned long scanning;
1263
	struct cfg80211_ssid scan_ssid;
1264
	struct cfg80211_scan_request *int_scan_req;
1265
	struct cfg80211_scan_request __rcu *scan_req;
1266
	struct ieee80211_scan_request *hw_scan_req;
1267
	struct cfg80211_chan_def scan_chandef;
1268
	enum nl80211_band hw_scan_band;
1269
	int scan_channel_idx;
1270
	int scan_ies_len;
1271
	int hw_scan_ies_bufsize;
1272
	struct cfg80211_scan_info scan_info;
1273

1274
	struct work_struct sched_scan_stopped_work;
1275
	struct ieee80211_sub_if_data __rcu *sched_scan_sdata;
1276
	struct cfg80211_sched_scan_request __rcu *sched_scan_req;
1277
	u8 scan_addr[ETH_ALEN];
1278

1279
	unsigned long leave_oper_channel_time;
1280
	enum mac80211_scan_state next_scan_state;
1281
	struct delayed_work scan_work;
1282
	struct ieee80211_sub_if_data __rcu *scan_sdata;
J
Johannes Berg 已提交
1283
	/* For backward compatibility only -- do not use */
1284
	struct cfg80211_chan_def _oper_chandef;
1285

1286 1287 1288
	/* Temporary remain-on-channel for off-channel operations */
	struct ieee80211_channel *tmp_channel;

1289 1290 1291 1292
	/* channel contexts */
	struct list_head chanctx_list;
	struct mutex chanctx_mtx;

1293
#ifdef CONFIG_MAC80211_LEDS
1294 1295 1296 1297
	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;
1298 1299 1300 1301
	struct tpt_led_trigger *tpt_led_trigger;
#endif

#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325
	/* 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;
1326
	unsigned int rx_expand_skb_head_defrag;
1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337
	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
				*/
1338

1339
	bool pspolling;
1340
	bool offchannel_ps_enabled;
1341 1342 1343 1344 1345
	/*
	 * 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;
1346 1347 1348
	struct work_struct dynamic_ps_enable_work;
	struct work_struct dynamic_ps_disable_work;
	struct timer_list dynamic_ps_timer;
1349
	struct notifier_block ifa_notifier;
1350
	struct notifier_block ifa6_notifier;
1351

1352 1353 1354 1355 1356 1357
	/*
	 * The dynamic ps timeout configured from user space via WEXT -
	 * this will override whatever chosen by mac80211 internally.
	 */
	int dynamic_ps_forced_timeout;

1358
	int user_power_level; /* in dBm, for all interfaces */
1359

1360 1361
	enum ieee80211_smps_mode smps_mode;

1362 1363
	struct work_struct restart_work;

J
Jiri Benc 已提交
1364 1365
#ifdef CONFIG_MAC80211_DEBUGFS
	struct local_debugfsdentries {
1366
		struct dentry *rcdir;
J
Jiri Benc 已提交
1367 1368 1369
		struct dentry *keys;
	} debugfs;
#endif
1370

1371 1372 1373
	/*
	 * Remain-on-channel support
	 */
1374
	struct delayed_work roc_work;
1375
	struct list_head roc_list;
1376
	struct work_struct hw_roc_start, hw_roc_done;
1377
	unsigned long hw_roc_start_time;
1378
	u64 roc_cookie_counter;
1379

J
Johannes Berg 已提交
1380 1381 1382
	struct idr ack_status_frames;
	spinlock_t ack_status_lock;

1383 1384
	struct ieee80211_sub_if_data __rcu *p2p_sdata;

1385 1386
	/* virtual monitor interface */
	struct ieee80211_sub_if_data __rcu *monitor_sdata;
1387
	struct cfg80211_chan_def monitor_chandef;
1388 1389 1390

	/* extended capabilities provided by mac80211 */
	u8 ext_capa[8];
1391 1392 1393 1394

	/* TDLS channel switch */
	struct work_struct tdls_chsw_work;
	struct sk_buff_head skb_queue_tdls_chsw;
1395 1396
};

1397 1398 1399 1400 1401 1402
static inline struct ieee80211_sub_if_data *
IEEE80211_DEV_TO_SUB_IF(struct net_device *dev)
{
	return netdev_priv(dev);
}

1403 1404 1405 1406 1407 1408
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);
}

1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
static inline struct ieee80211_supported_band *
ieee80211_get_sband(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_chanctx_conf *chanctx_conf;
	enum nl80211_band band;

	rcu_read_lock();
	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);

	if (WARN_ON(!chanctx_conf)) {
		rcu_read_unlock();
		return NULL;
	}

	band = chanctx_conf->def.chan->band;
	rcu_read_unlock();

	return local->hw.wiphy->bands[band];
}

1430
/* this struct represents 802.11n's RA/TID combination */
1431 1432 1433 1434 1435
struct ieee80211_ra_tid {
	u8 ra[ETH_ALEN];
	u16 tid;
};

1436 1437 1438 1439 1440 1441
/* 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;
1442
	u16 pre_value;
1443 1444
};

1445 1446
/* Parsed Information Elements */
struct ieee802_11_elems {
J
Johannes Berg 已提交
1447
	const u8 *ie_start;
1448 1449 1450
	size_t total_len;

	/* pointers to IEs */
1451 1452
	const struct ieee80211_tdls_lnkie *lnk_id;
	const struct ieee80211_ch_switch_timing *ch_sw_timing;
1453
	const u8 *ext_capab;
J
Johannes Berg 已提交
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476
	const u8 *ssid;
	const u8 *supp_rates;
	const u8 *ds_params;
	const struct ieee80211_tim_ie *tim;
	const u8 *challenge;
	const u8 *rsn;
	const u8 *erp_info;
	const u8 *ext_supp_rates;
	const u8 *wmm_info;
	const u8 *wmm_param;
	const struct ieee80211_ht_cap *ht_cap_elem;
	const struct ieee80211_ht_operation *ht_operation;
	const struct ieee80211_vht_cap *vht_cap_elem;
	const struct ieee80211_vht_operation *vht_operation;
	const struct ieee80211_meshconf_ie *mesh_config;
	const u8 *mesh_id;
	const u8 *peering;
	const __le16 *awake_window;
	const u8 *preq;
	const u8 *prep;
	const u8 *perr;
	const struct ieee80211_rann_ie *rann;
	const struct ieee80211_channel_sw_ie *ch_switch_ie;
1477
	const struct ieee80211_ext_chansw_ie *ext_chansw_ie;
1478
	const struct ieee80211_wide_bw_chansw_ie *wide_bw_chansw_ie;
J
Johannes Berg 已提交
1479 1480
	const u8 *country_elem;
	const u8 *pwr_constr_elem;
1481
	const u8 *cisco_dtpc_elem;
1482
	const struct ieee80211_timeout_interval_ie *timeout_int;
J
Johannes Berg 已提交
1483
	const u8 *opmode_notif;
1484
	const struct ieee80211_sec_chan_offs_ie *sec_chan_offs;
1485
	const struct ieee80211_mesh_chansw_params_ie *mesh_chansw_params_ie;
1486
	const struct ieee80211_bss_max_idle_period_ie *max_idle_period_ie;
1487 1488

	/* length of them, respectively */
1489
	u8 ext_capab_len;
1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503
	u8 ssid_len;
	u8 supp_rates_len;
	u8 tim_len;
	u8 challenge_len;
	u8 rsn_len;
	u8 ext_supp_rates_len;
	u8 wmm_info_len;
	u8 wmm_param_len;
	u8 mesh_id_len;
	u8 peering_len;
	u8 preq_len;
	u8 prep_len;
	u8 perr_len;
	u8 country_elem_len;
P
Paul Stewart 已提交
1504 1505 1506

	/* whether a parse error occurred while retrieving these elements */
	bool parse_error;
1507 1508
};

1509 1510 1511 1512 1513 1514
static inline struct ieee80211_local *hw_to_local(
	struct ieee80211_hw *hw)
{
	return container_of(hw, struct ieee80211_local, hw);
}

1515 1516 1517 1518
static inline struct txq_info *to_txq_info(struct ieee80211_txq *txq)
{
	return container_of(txq, struct txq_info, txq);
}
1519

1520 1521 1522 1523 1524 1525 1526
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);
}

1527 1528
static inline int ieee80211_bssid_match(const u8 *raddr, const u8 *addr)
{
1529
	return ether_addr_equal(raddr, addr) ||
1530 1531 1532
	       is_broadcast_ether_addr(raddr);
}

1533 1534 1535 1536 1537
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);
1538 1539
	if (status->flag & (RX_FLAG_MACTIME_START | RX_FLAG_MACTIME_END))
		return true;
1540
	/* can't handle non-legacy preamble yet */
1541
	if (status->flag & RX_FLAG_MACTIME_PLCP_START &&
1542
	    status->encoding != RX_ENC_LEGACY)
1543 1544
		return true;
	return false;
1545
}
1546

1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
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;
}

1564 1565 1566 1567
u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
				     struct ieee80211_rx_status *status,
				     unsigned int mpdu_len,
				     unsigned int mpdu_offset);
1568
int ieee80211_hw_config(struct ieee80211_local *local, u32 changed);
1569
void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx);
J
Johannes Berg 已提交
1570 1571
void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
				      u32 changed);
1572
void ieee80211_configure_filter(struct ieee80211_local *local);
1573
u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata);
1574

1575
u64 ieee80211_mgmt_tx_cookie(struct ieee80211_local *local);
1576 1577
int ieee80211_attach_ack_skb(struct ieee80211_local *local, struct sk_buff *skb,
			     u64 *cookie, gfp_t gfp);
1578

J
Johannes Berg 已提交
1579 1580 1581 1582 1583
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);

1584
/* STA code */
J
Johannes Berg 已提交
1585
void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata);
1586 1587 1588 1589 1590
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,
1591
			 struct cfg80211_deauth_request *req);
1592
int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
1593
			   struct cfg80211_disassoc_request *req);
1594 1595
void ieee80211_send_pspoll(struct ieee80211_local *local,
			   struct ieee80211_sub_if_data *sdata);
J
Johannes Berg 已提交
1596
void ieee80211_recalc_ps(struct ieee80211_local *local);
E
Eliad Peller 已提交
1597
void ieee80211_recalc_ps_vif(struct ieee80211_sub_if_data *sdata);
1598
int ieee80211_set_arp_filter(struct ieee80211_sub_if_data *sdata);
1599 1600 1601
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);
1602
void ieee80211_sta_reset_beacon_monitor(struct ieee80211_sub_if_data *sdata);
1603
void ieee80211_sta_reset_conn_monitor(struct ieee80211_sub_if_data *sdata);
1604
void ieee80211_mgd_stop(struct ieee80211_sub_if_data *sdata);
1605 1606
void ieee80211_mgd_conn_tx_status(struct ieee80211_sub_if_data *sdata,
				  __le16 fc, bool acked);
1607
void ieee80211_mgd_quiesce(struct ieee80211_sub_if_data *sdata);
1608
void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata);
1609
void ieee80211_sta_handle_tspec_ac_params(struct ieee80211_sub_if_data *sdata);
J
Johannes Berg 已提交
1610

1611 1612 1613
/* IBSS code */
void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local);
void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata);
1614 1615
void ieee80211_ibss_rx_no_sta(struct ieee80211_sub_if_data *sdata,
			      const u8 *bssid, const u8 *addr, u32 supp_rates);
1616 1617 1618
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);
1619 1620 1621
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);
1622 1623 1624 1625
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);
1626

1627 1628 1629 1630 1631 1632 1633 1634 1635
/* 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);

1636 1637 1638 1639
/* 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);
1640
int ieee80211_mesh_csa_beacon(struct ieee80211_sub_if_data *sdata,
1641
			      struct cfg80211_csa_settings *csa_settings);
1642
int ieee80211_mesh_finish_csa(struct ieee80211_sub_if_data *sdata);
1643

J
Johannes Berg 已提交
1644
/* scan/BSS handling */
1645
void ieee80211_scan_work(struct work_struct *work);
S
Stanislaw Gruszka 已提交
1646 1647
int ieee80211_request_ibss_scan(struct ieee80211_sub_if_data *sdata,
				const u8 *ssid, u8 ssid_len,
1648 1649
				struct ieee80211_channel **channels,
				unsigned int n_channels,
1650
				enum nl80211_bss_scan_width scan_width);
1651
int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
1652
			   struct cfg80211_scan_request *req);
1653
void ieee80211_scan_cancel(struct ieee80211_local *local);
1654
void ieee80211_run_deferred_scan(struct ieee80211_local *local);
J
Johannes Berg 已提交
1655
void ieee80211_scan_rx(struct ieee80211_local *local, struct sk_buff *skb);
J
Johannes Berg 已提交
1656

1657
void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local);
1658
struct ieee80211_bss *
1659 1660 1661 1662 1663
ieee80211_bss_info_update(struct ieee80211_local *local,
			  struct ieee80211_rx_status *rx_status,
			  struct ieee80211_mgmt *mgmt,
			  size_t len,
			  struct ieee802_11_elems *elems,
1664
			  struct ieee80211_channel *channel);
1665
void ieee80211_rx_bss_put(struct ieee80211_local *local,
1666
			  struct ieee80211_bss *bss);
1667

1668
/* scheduled scan handling */
1669 1670 1671
int
__ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
				     struct cfg80211_sched_scan_request *req);
1672 1673
int ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
				       struct cfg80211_sched_scan_request *req);
1674
int ieee80211_request_sched_scan_stop(struct ieee80211_local *local);
1675
void ieee80211_sched_scan_end(struct ieee80211_local *local);
1676
void ieee80211_sched_scan_stopped_work(struct work_struct *work);
1677

1678
/* off-channel/mgmt-tx */
1679 1680
void ieee80211_offchannel_stop_vifs(struct ieee80211_local *local);
void ieee80211_offchannel_return(struct ieee80211_local *local);
1681 1682
void ieee80211_roc_setup(struct ieee80211_local *local);
void ieee80211_start_next_roc(struct ieee80211_local *local);
1683 1684
void ieee80211_roc_purge(struct ieee80211_local *local,
			 struct ieee80211_sub_if_data *sdata);
1685 1686 1687 1688 1689 1690 1691 1692 1693
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);
1694

1695 1696
/* channel switch handling */
void ieee80211_csa_finalize_work(struct work_struct *work);
1697 1698
int ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
			     struct cfg80211_csa_settings *params);
1699

1700
/* interface handling */
1701 1702
int ieee80211_iface_init(void);
void ieee80211_iface_exit(void);
1703
int ieee80211_if_add(struct ieee80211_local *local, const char *name,
1704
		     unsigned char name_assign_type,
1705
		     struct wireless_dev **new_wdev, enum nl80211_iftype type,
1706
		     struct vif_params *params);
1707
int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
1708
			     enum nl80211_iftype type);
1709
void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata);
1710
void ieee80211_remove_interfaces(struct ieee80211_local *local);
1711
u32 ieee80211_idle_off(struct ieee80211_local *local);
J
Johannes Berg 已提交
1712
void ieee80211_recalc_idle(struct ieee80211_local *local);
1713 1714
void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
				    const int offset);
1715 1716
int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up);
void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata);
1717 1718
int ieee80211_add_virtual_monitor(struct ieee80211_local *local);
void ieee80211_del_virtual_monitor(struct ieee80211_local *local);
1719

1720
bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata);
1721 1722
void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata,
			      bool update_bss);
1723

1724 1725
static inline bool ieee80211_sdata_running(struct ieee80211_sub_if_data *sdata)
{
1726
	return test_bit(SDATA_STATE_RUNNING, &sdata->state);
1727 1728
}

1729 1730 1731
/* tx handling */
void ieee80211_clear_tx_pending(struct ieee80211_local *local);
void ieee80211_tx_pending(unsigned long data);
1732 1733 1734 1735
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);
1736 1737 1738
void __ieee80211_subif_start_xmit(struct sk_buff *skb,
				  struct net_device *dev,
				  u32 info_flags);
1739 1740
void ieee80211_purge_tx_queue(struct ieee80211_hw *hw,
			      struct sk_buff_head *skbs);
1741 1742 1743
struct sk_buff *
ieee80211_build_data_template(struct ieee80211_sub_if_data *sdata,
			      struct sk_buff *skb, u32 info_flags);
1744 1745 1746
void ieee80211_tx_monitor(struct ieee80211_local *local, struct sk_buff *skb,
			  struct ieee80211_supported_band *sband,
			  int retry_count, int shift, bool send_to_cooked);
1747

J
Johannes Berg 已提交
1748 1749 1750 1751 1752
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);

1753
/* HT */
B
Ben Greear 已提交
1754 1755
void ieee80211_apply_htcap_overrides(struct ieee80211_sub_if_data *sdata,
				     struct ieee80211_sta_ht_cap *ht_cap);
1756
bool ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_sub_if_data *sdata,
B
Ben Greear 已提交
1757
				       struct ieee80211_supported_band *sband,
J
Johannes Berg 已提交
1758
				       const struct ieee80211_ht_cap *ht_cap_ie,
1759
				       struct sta_info *sta);
J
Johannes Berg 已提交
1760 1761 1762
void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata,
			  const u8 *da, u16 tid,
			  u16 initiator, u16 reason_code);
1763 1764 1765
int ieee80211_send_smps_action(struct ieee80211_sub_if_data *sdata,
			       enum ieee80211_smps_mode smps, const u8 *da,
			       const u8 *bssid);
1766 1767 1768 1769
void ieee80211_request_smps_ap_work(struct work_struct *work);
void ieee80211_request_smps_mgd_work(struct work_struct *work);
bool ieee80211_smps_is_restrictive(enum ieee80211_smps_mode smps_mode_old,
				   enum ieee80211_smps_mode smps_mode_new);
1770

1771
void ___ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
1772
				     u16 initiator, u16 reason, bool stop);
1773
void __ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
1774
				    u16 initiator, u16 reason, bool stop);
1775 1776 1777
void __ieee80211_start_rx_ba_session(struct sta_info *sta,
				     u8 dialog_token, u16 timeout,
				     u16 start_seq_num, u16 ba_policy, u16 tid,
1778
				     u16 buf_size, bool tx, bool auto_seq);
1779 1780
void ieee80211_sta_tear_down_BA_sessions(struct sta_info *sta,
					 enum ieee80211_agg_stop_reason reason);
1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792
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);

1793
int __ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
1794
				   enum ieee80211_agg_stop_reason reason);
J
Johannes Berg 已提交
1795
int ___ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
1796
				    enum ieee80211_agg_stop_reason reason);
1797 1798
void ieee80211_start_tx_ba_cb(struct ieee80211_vif *vif, u8 *ra, u16 tid);
void ieee80211_stop_tx_ba_cb(struct ieee80211_vif *vif, u8 *ra, u8 tid);
J
Johannes Berg 已提交
1799 1800
void ieee80211_ba_session_work(struct work_struct *work);
void ieee80211_tx_ba_session_handle_start(struct sta_info *sta, int tid);
1801
void ieee80211_release_reorder_timeout(struct sta_info *sta, int tid);
1802

1803 1804
u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs);

M
Mahesh Palivela 已提交
1805
/* VHT */
J
Johannes Berg 已提交
1806 1807 1808 1809 1810
void
ieee80211_vht_cap_ie_to_sta_vht_cap(struct ieee80211_sub_if_data *sdata,
				    struct ieee80211_supported_band *sband,
				    const struct ieee80211_vht_cap *vht_cap_ie,
				    struct sta_info *sta);
1811
enum ieee80211_sta_rx_bandwidth ieee80211_sta_cap_rx_bw(struct sta_info *sta);
1812
enum ieee80211_sta_rx_bandwidth ieee80211_sta_cur_vht_bw(struct sta_info *sta);
1813
void ieee80211_sta_set_rx_nss(struct sta_info *sta);
1814 1815 1816 1817
enum ieee80211_sta_rx_bandwidth
ieee80211_chan_width_to_rx_bw(enum nl80211_chan_width width);
enum nl80211_chan_width ieee80211_sta_cap_chan_bw(struct sta_info *sta);
void ieee80211_sta_set_rx_nss(struct sta_info *sta);
1818 1819
void ieee80211_process_mu_groups(struct ieee80211_sub_if_data *sdata,
				 struct ieee80211_mgmt *mgmt);
1820 1821
u32 __ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
                                  struct sta_info *sta, u8 opmode,
1822
				  enum nl80211_band band);
1823 1824
void ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
				 struct sta_info *sta, u8 opmode,
1825
				 enum nl80211_band band);
1826 1827
void ieee80211_apply_vhtcap_overrides(struct ieee80211_sub_if_data *sdata,
				      struct ieee80211_sta_vht_cap *vht_cap);
1828 1829
void ieee80211_get_vht_mask_from_cap(__le16 vht_cap,
				     u16 vht_mask[NL80211_VHT_NSS_MAX]);
1830

1831 1832 1833 1834
/* Spectrum management */
void ieee80211_process_measurement_req(struct ieee80211_sub_if_data *sdata,
				       struct ieee80211_mgmt *mgmt,
				       size_t len);
1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846
/**
 * ieee80211_parse_ch_switch_ie - parses channel switch IEs
 * @sdata: the sdata of the interface which has received the frame
 * @elems: parsed 802.11 elements received with the frame
 * @current_band: indicates the current band
 * @sta_flags: contains information about own capabilities and restrictions
 *	to decide which channel switch announcements can be accepted. Only the
 *	following subset of &enum ieee80211_sta_flags are evaluated:
 *	%IEEE80211_STA_DISABLE_HT, %IEEE80211_STA_DISABLE_VHT,
 *	%IEEE80211_STA_DISABLE_40MHZ, %IEEE80211_STA_DISABLE_80P80MHZ,
 *	%IEEE80211_STA_DISABLE_160MHZ.
 * @bssid: the currently connected bssid (for reporting)
1847 1848
 * @csa_ie: parsed 802.11 csa elements on count, mode, chandef and mesh ttl.
	All of them will be filled with if success only.
1849 1850 1851
 * 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,
1852
				 struct ieee802_11_elems *elems,
1853
				 enum nl80211_band current_band,
1854 1855
				 u32 sta_flags, u8 *bssid,
				 struct ieee80211_csa_ie *csa_ie);
1856

1857 1858
/* Suspend/resume and hw reconfiguration */
int ieee80211_reconfig(struct ieee80211_local *local);
1859
void ieee80211_stop_device(struct ieee80211_local *local);
1860

1861 1862
int __ieee80211_suspend(struct ieee80211_hw *hw,
			struct cfg80211_wowlan *wowlan);
1863 1864 1865

static inline int __ieee80211_resume(struct ieee80211_hw *hw)
{
1866 1867
	struct ieee80211_local *local = hw_to_local(hw);

1868 1869
	WARN(test_bit(SCAN_HW_SCANNING, &local->scanning) &&
	     !test_bit(SCAN_COMPLETED, &local->scanning),
1870 1871 1872
		"%s: resume with hardware scan still in progress\n",
		wiphy_name(hw->wiphy));

1873 1874
	return ieee80211_reconfig(hw_to_local(hw));
}
1875

J
Johannes Berg 已提交
1876
/* utility functions/constants */
1877
extern const void *const mac80211_wiphy_privid; /* for wiphy privid */
1878
int ieee80211_frame_duration(enum nl80211_band band, size_t len,
1879 1880
			     int rate, int erp, int short_preamble,
			     int shift);
1881
void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
1882
			       bool bss_notify, bool enable_qos);
1883 1884
void ieee80211_xmit(struct ieee80211_sub_if_data *sdata,
		    struct sta_info *sta, struct sk_buff *skb);
J
Johannes Berg 已提交
1885 1886 1887

void __ieee80211_tx_skb_tid_band(struct ieee80211_sub_if_data *sdata,
				 struct sk_buff *skb, int tid,
1888
				 enum nl80211_band band);
J
Johannes Berg 已提交
1889 1890 1891 1892

static inline void
ieee80211_tx_skb_tid_band(struct ieee80211_sub_if_data *sdata,
			  struct sk_buff *skb, int tid,
1893
			  enum nl80211_band band)
J
Johannes Berg 已提交
1894 1895 1896 1897 1898
{
	rcu_read_lock();
	__ieee80211_tx_skb_tid_band(sdata, skb, tid, band);
	rcu_read_unlock();
}
1899

J
Johannes Berg 已提交
1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913
static inline void ieee80211_tx_skb_tid(struct ieee80211_sub_if_data *sdata,
					struct sk_buff *skb, int tid)
{
	struct ieee80211_chanctx_conf *chanctx_conf;

	rcu_read_lock();
	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
	if (WARN_ON(!chanctx_conf)) {
		rcu_read_unlock();
		kfree_skb(skb);
		return;
	}

	__ieee80211_tx_skb_tid_band(sdata, skb, tid,
1914
				    chanctx_conf->def.chan->band);
J
Johannes Berg 已提交
1915 1916 1917 1918
	rcu_read_unlock();
}

static inline void ieee80211_tx_skb(struct ieee80211_sub_if_data *sdata,
1919 1920 1921 1922 1923 1924
				    struct sk_buff *skb)
{
	/* Send all internal mgmt frames on VO. Accordingly set TID to 7. */
	ieee80211_tx_skb_tid(sdata, skb, 7);
}

1925
u32 ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
1926 1927
			       struct ieee802_11_elems *elems,
			       u64 filter, u32 crc);
1928 1929
static inline void ieee802_11_parse_elems(const u8 *start, size_t len,
					  bool action,
1930 1931
					  struct ieee802_11_elems *elems)
{
1932
	ieee802_11_parse_elems_crc(start, len, action, elems, 0, 0);
1933 1934
}

1935

1936 1937 1938 1939 1940 1941 1942
extern const int ieee802_1d_to_ac[8];

static inline int ieee80211_ac_from_tid(int tid)
{
	return ieee802_1d_to_ac[tid & 7];
}

1943 1944 1945
void ieee80211_dynamic_ps_enable_work(struct work_struct *work);
void ieee80211_dynamic_ps_disable_work(struct work_struct *work);
void ieee80211_dynamic_ps_timer(unsigned long data);
1946 1947
void ieee80211_send_nullfunc(struct ieee80211_local *local,
			     struct ieee80211_sub_if_data *sdata,
1948
			     bool powersave);
1949 1950
void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
			     struct ieee80211_hdr *hdr);
1951
void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata,
1952
			     struct ieee80211_hdr *hdr, bool ack, u16 tx_time);
1953

K
Kalle Valo 已提交
1954
void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
1955
				     unsigned long queues,
1956 1957
				     enum queue_stop_reason reason,
				     bool refcounted);
1958 1959 1960 1961 1962 1963
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);
K
Kalle Valo 已提交
1964
void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
1965
				     unsigned long queues,
1966 1967
				     enum queue_stop_reason reason,
				     bool refcounted);
1968
void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
1969 1970
				    enum queue_stop_reason reason,
				    bool refcounted);
1971
void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
1972 1973
				    enum queue_stop_reason reason,
				    bool refcounted);
1974
void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue);
1975 1976
void ieee80211_add_pending_skb(struct ieee80211_local *local,
			       struct sk_buff *skb);
1977 1978
void ieee80211_add_pending_skbs(struct ieee80211_local *local,
				struct sk_buff_head *skbs);
1979
void ieee80211_flush_queues(struct ieee80211_local *local,
1980
			    struct ieee80211_sub_if_data *sdata, bool drop);
1981 1982
void __ieee80211_flush_queues(struct ieee80211_local *local,
			      struct ieee80211_sub_if_data *sdata,
1983
			      unsigned int queues, bool drop);
K
Kalle Valo 已提交
1984

1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014
static inline bool ieee80211_can_run_worker(struct ieee80211_local *local)
{
	/*
	 * If quiescing is set, we are racing with __ieee80211_suspend.
	 * __ieee80211_suspend flushes the workers after setting quiescing,
	 * and we check quiescing / suspended before enqueing new workers.
	 * We should abort the worker to avoid the races below.
	 */
	if (local->quiescing)
		return false;

	/*
	 * We might already be suspended if the following scenario occurs:
	 * __ieee80211_suspend		Control path
	 *
	 *				if (local->quiescing)
	 *					return;
	 * local->quiescing = true;
	 * flush_workqueue();
	 *				queue_work(...);
	 * local->suspended = true;
	 * local->quiescing = false;
	 *				worker starts running...
	 */
	if (local->suspended)
		return false;

	return true;
}

2015 2016 2017 2018 2019 2020 2021
int ieee80211_txq_setup_flows(struct ieee80211_local *local);
void ieee80211_txq_teardown_flows(struct ieee80211_local *local);
void ieee80211_txq_init(struct ieee80211_sub_if_data *sdata,
			struct sta_info *sta,
			struct txq_info *txq, int tid);
void ieee80211_txq_purge(struct ieee80211_local *local,
			 struct txq_info *txqi);
2022
void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
2023
			 u16 transaction, u16 auth_alg, u16 status,
J
Johannes Berg 已提交
2024
			 const u8 *extra, size_t extra_len, const u8 *bssid,
2025 2026
			 const u8 *da, const u8 *key, u8 key_len, u8 key_idx,
			 u32 tx_flags);
2027 2028 2029
void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
				    const u8 *bssid, u16 stype, u16 reason,
				    bool send_frame, u8 *frame_buf);
2030
int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
2031 2032 2033 2034
			     size_t buffer_len,
			     struct ieee80211_scan_ies *ie_desc,
			     const u8 *ie, size_t ie_len,
			     u8 bands_used, u32 *rate_masks,
2035
			     struct cfg80211_chan_def *chandef);
2036
struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
2037 2038
					  const u8 *src, const u8 *dst,
					  u32 ratemask,
2039
					  struct ieee80211_channel *chan,
2040
					  const u8 *ssid, size_t ssid_len,
2041 2042
					  const u8 *ie, size_t ie_len,
					  bool directed);
2043 2044
void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata,
			      const u8 *src, const u8 *dst,
2045
			      const u8 *ssid, size_t ssid_len,
2046
			      const u8 *ie, size_t ie_len,
2047
			      u32 ratemask, bool directed, u32 tx_flags,
J
Johannes Berg 已提交
2048
			      struct ieee80211_channel *channel, bool scan);
2049

2050
u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata,
2051
			    struct ieee802_11_elems *elems,
2052
			    enum nl80211_band band, u32 *basic_rates);
2053 2054 2055 2056
int __ieee80211_request_smps_mgd(struct ieee80211_sub_if_data *sdata,
				 enum ieee80211_smps_mode smps_mode);
int __ieee80211_request_smps_ap(struct ieee80211_sub_if_data *sdata,
				enum ieee80211_smps_mode smps_mode);
2057
void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata);
2058
void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata);
2059

2060
size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset);
B
Ben Greear 已提交
2061
u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
2062
			      u16 cap);
2063
u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
2064
			       const struct cfg80211_chan_def *chandef,
2065
			       u16 prot_mode, bool rifs_mode);
2066 2067
u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
			       u32 cap);
2068 2069
u8 *ieee80211_ie_build_vht_oper(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
				const struct cfg80211_chan_def *chandef);
2070 2071 2072
int ieee80211_parse_bitrates(struct cfg80211_chan_def *chandef,
			     const struct ieee80211_supported_band *sband,
			     const u8 *srates, int srates_len, u32 *rates);
2073
int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata,
2074
			    struct sk_buff *skb, bool need_basic,
2075
			    enum nl80211_band band);
2076
int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata,
2077
				struct sk_buff *skb, bool need_basic,
2078
				enum nl80211_band band);
2079
u8 *ieee80211_add_wmm_info_ie(u8 *buf, u8 qosinfo);
2080

2081
/* channel management */
2082 2083 2084 2085
bool ieee80211_chandef_ht_oper(const struct ieee80211_ht_operation *ht_oper,
			       struct cfg80211_chan_def *chandef);
bool ieee80211_chandef_vht_oper(const struct ieee80211_vht_operation *oper,
				struct cfg80211_chan_def *chandef);
2086
u32 ieee80211_chandef_downgrade(struct cfg80211_chan_def *c);
2087

2088 2089
int __must_check
ieee80211_vif_use_channel(struct ieee80211_sub_if_data *sdata,
2090
			  const struct cfg80211_chan_def *chandef,
2091
			  enum ieee80211_chanctx_mode mode);
2092 2093 2094
int __must_check
ieee80211_vif_reserve_chanctx(struct ieee80211_sub_if_data *sdata,
			      const struct cfg80211_chan_def *chandef,
2095 2096
			      enum ieee80211_chanctx_mode mode,
			      bool radar_required);
2097
int __must_check
2098
ieee80211_vif_use_reserved_context(struct ieee80211_sub_if_data *sdata);
2099 2100
int ieee80211_vif_unreserve_chanctx(struct ieee80211_sub_if_data *sdata);

2101 2102 2103 2104
int __must_check
ieee80211_vif_change_bandwidth(struct ieee80211_sub_if_data *sdata,
			       const struct cfg80211_chan_def *chandef,
			       u32 *changed);
2105
void ieee80211_vif_release_channel(struct ieee80211_sub_if_data *sdata);
2106
void ieee80211_vif_vlan_copy_chanctx(struct ieee80211_sub_if_data *sdata);
2107 2108
void ieee80211_vif_copy_chanctx_to_vlans(struct ieee80211_sub_if_data *sdata,
					 bool clear);
2109 2110
int ieee80211_chanctx_refcount(struct ieee80211_local *local,
			       struct ieee80211_chanctx *ctx);
2111

2112 2113
void ieee80211_recalc_smps_chanctx(struct ieee80211_local *local,
				   struct ieee80211_chanctx *chanctx);
2114 2115
void ieee80211_recalc_chanctx_min_def(struct ieee80211_local *local,
				      struct ieee80211_chanctx *ctx);
2116
bool ieee80211_is_radar_required(struct ieee80211_local *local);
2117 2118 2119 2120 2121

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);
2122 2123
int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
			      struct cfg80211_csa_settings *csa_settings);
2124

2125 2126 2127 2128 2129 2130 2131 2132
bool ieee80211_cs_valid(const struct ieee80211_cipher_scheme *cs);
bool ieee80211_cs_list_valid(const struct ieee80211_cipher_scheme *cs, int n);
const struct ieee80211_cipher_scheme *
ieee80211_cs_get(struct ieee80211_local *local, u32 cipher,
		 enum nl80211_iftype iftype);
int ieee80211_cs_headroom(struct ieee80211_local *local,
			  struct cfg80211_crypto_settings *crypto,
			  enum nl80211_iftype iftype);
2133 2134
void ieee80211_recalc_dtim(struct ieee80211_local *local,
			   struct ieee80211_sub_if_data *sdata);
2135 2136 2137 2138
int ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata,
				 const struct cfg80211_chan_def *chandef,
				 enum ieee80211_chanctx_mode chanmode,
				 u8 radar_detect);
2139
int ieee80211_max_num_channels(struct ieee80211_local *local);
2140 2141 2142
enum nl80211_chan_width ieee80211_get_sta_bw(struct ieee80211_sta *sta);
void ieee80211_recalc_chanctx_chantype(struct ieee80211_local *local,
				       struct ieee80211_chanctx *ctx);
2143

2144 2145
/* TDLS */
int ieee80211_tdls_mgmt(struct wiphy *wiphy, struct net_device *dev,
2146
			const u8 *peer, u8 action_code, u8 dialog_token,
2147
			u16 status_code, u32 peer_capability,
2148 2149
			bool initiator, const u8 *extra_ies,
			size_t extra_ies_len);
2150
int ieee80211_tdls_oper(struct wiphy *wiphy, struct net_device *dev,
2151
			const u8 *peer, enum nl80211_tdls_operation oper);
J
Johannes Berg 已提交
2152
void ieee80211_tdls_peer_del_work(struct work_struct *wk);
2153 2154 2155 2156 2157 2158
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);
2159
void ieee80211_teardown_tdls_peers(struct ieee80211_sub_if_data *sdata);
2160
void ieee80211_tdls_chsw_work(struct work_struct *wk);
2161

2162 2163
extern const struct ethtool_ops ieee80211_ethtool_ops;

2164
#ifdef CONFIG_MAC80211_NOINLINE
2165 2166 2167 2168 2169
#define debug_noinline noinline
#else
#define debug_noinline
#endif

2170
#endif /* IEEE80211_I_H */