ieee80211_i.h 58.1 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 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 * 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>
25
#include <linux/etherdevice.h>
26
#include <linux/leds.h>
J
Johannes Berg 已提交
27
#include <linux/idr.h>
J
Johannes Berg 已提交
28
#include <net/ieee80211_radiotap.h>
29
#include <net/cfg80211.h>
30
#include <net/mac80211.h>
J
Johannes Berg 已提交
31
#include "key.h"
32
#include "sta_info.h"
J
Johannes Berg 已提交
33
#include "debug.h"
34

35
struct ieee80211_local;
36 37 38 39 40 41 42 43 44 45 46 47

/* 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
48
#define IEEE80211_ENCRYPT_TAILROOM 18
49 50 51 52 53 54 55

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

56 57 58
/* power level hasn't been configured (or set to automatic) */
#define IEEE80211_UNSET_POWER_LEVEL	INT_MIN

59 60 61 62 63 64
/*
 * Some APs experience problems when working with U-APSD. Decrease the
 * probability of that happening by using legacy mode for all ACs but VO.
 * The AP that caused us trouble was a Cisco 4410N. It ignores our
 * setting, and always treats non-VO ACs as legacy.
 */
K
Kalle Valo 已提交
65
#define IEEE80211_DEFAULT_UAPSD_QUEUES \
66
	IEEE80211_WMM_IE_STA_QOSINFO_AC_VO
K
Kalle Valo 已提交
67 68 69 70

#define IEEE80211_DEFAULT_MAX_SP_LEN		\
	IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL

71 72
#define IEEE80211_DEAUTH_FRAME_LEN	(24 /* hdr */ + 2 /* reason */)

73 74 75 76 77 78 79 80 81 82 83 84
struct ieee80211_fragment_entry {
	unsigned long first_frag_time;
	unsigned int seq;
	unsigned int rx_queue;
	unsigned int last_frag;
	unsigned int extra_len;
	struct sk_buff_head skb_list;
	int ccmp; /* Whether fragments were encrypted with CCMP */
	u8 last_pn[6]; /* PN of the last fragment if CCMP was used */
};


85
struct ieee80211_bss {
86
	u32 device_ts_beacon, device_ts_presp;
87

88
	bool wmm_used;
K
Kalle Valo 已提交
89
	bool uapsd_supported;
90

91 92 93
#define IEEE80211_MAX_SUPP_RATES 32
	u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
	size_t supp_rates_len;
94
	struct ieee80211_rate *beacon_rate;
95

96
	/*
L
Lucas De Marchi 已提交
97
	 * During association, we save an ERP value from a probe response so
98 99
	 * that we can feed ERP info to the driver when handling the
	 * association completes. these fields probably won't be up-to-date
100 101 102
	 * otherwise, you probably don't want to use them.
	 */
	bool has_erp_value;
103
	u8 erp_value;
P
Paul Stewart 已提交
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139

	/* 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
 * of the data structure were recieved as a result of an un-corrupted
 * 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)
140 141
};

142 143 144 145 146
typedef unsigned __bitwise__ ieee80211_tx_result;
#define TX_CONTINUE	((__force ieee80211_tx_result) 0u)
#define TX_DROP		((__force ieee80211_tx_result) 1u)
#define TX_QUEUED	((__force ieee80211_tx_result) 2u)

147 148 149 150 151
#define IEEE80211_TX_UNICAST		BIT(1)
#define IEEE80211_TX_PS_BUFFERED	BIT(2)

struct ieee80211_tx_data {
	struct sk_buff *skb;
152
	struct sk_buff_head skbs;
153 154 155 156
	struct ieee80211_local *local;
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;
	struct ieee80211_key *key;
157
	struct ieee80211_tx_rate rate;
158

159
	unsigned int flags;
160 161 162
};


163
typedef unsigned __bitwise__ ieee80211_rx_result;
J
Johannes Berg 已提交
164 165 166 167
#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)
168

169 170 171 172 173 174 175
/**
 * enum ieee80211_packet_rx_flags - packet RX flags
 * @IEEE80211_RX_RA_MATCH: frame is destined to interface currently processed
 *	(incl. multicast frames)
 * @IEEE80211_RX_FRAGMENTED: fragmented frame
 * @IEEE80211_RX_AMSDU: a-MSDU packet
 * @IEEE80211_RX_MALFORMED_ACTION_FRM: action frame is malformed
176
 * @IEEE80211_RX_DEFERRED_RELEASE: frame was subjected to receive reordering
177 178 179 180 181 182 183 184 185
 *
 * 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_RA_MATCH			= BIT(1),
	IEEE80211_RX_FRAGMENTED			= BIT(2),
	IEEE80211_RX_AMSDU			= BIT(3),
	IEEE80211_RX_MALFORMED_ACTION_FRM	= BIT(4),
186
	IEEE80211_RX_DEFERRED_RELEASE		= BIT(5),
187 188 189 190 191 192
};

/**
 * enum ieee80211_rx_flags - RX data flags
 *
 * @IEEE80211_RX_CMNTR: received on cooked monitor already
J
Johannes Berg 已提交
193 194
 * @IEEE80211_RX_BEACON_REPORTED: This frame was already reported
 *	to cfg80211_report_obss_beacon().
195 196 197 198 199 200
 *
 * These flags are used across handling multiple interfaces
 * for a single frame.
 */
enum ieee80211_rx_flags {
	IEEE80211_RX_CMNTR		= BIT(0),
J
Johannes Berg 已提交
201
	IEEE80211_RX_BEACON_REPORTED	= BIT(1),
202
};
203 204

struct ieee80211_rx_data {
205 206 207 208 209
	struct sk_buff *skb;
	struct ieee80211_local *local;
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;
	struct ieee80211_key *key;
210 211

	unsigned int flags;
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227

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

228 229
	u32 tkip_iv32;
	u16 tkip_iv16;
230 231
};

232 233 234
struct beacon_data {
	u8 *head, *tail;
	int head_len, tail_len;
235
	struct ieee80211_meshconf_ie *meshconf;
236
	struct rcu_head rcu_head;
237 238
};

239 240 241 242 243 244
struct probe_resp {
	struct rcu_head rcu_head;
	int len;
	u8 data[0];
};

245
struct ps_data {
246 247
	/* yes, this looks ugly, but guarantees that we can later use
	 * bitmap_empty :)
248
	 * NB: don't touch this bitmap, use sta_info_{set,clear}_tim_bit */
249 250
	u8 tim[sizeof(unsigned long) * BITS_TO_LONGS(IEEE80211_MAX_AID + 1)]
			__aligned(__alignof__(unsigned long));
251
	struct sk_buff_head bc_buf;
252
	atomic_t num_sta_ps; /* number of stations in PS mode */
253
	int dtim_count;
254
	bool dtim_bc_mc;
255 256
};

257 258 259 260
struct ieee80211_if_ap {
	struct beacon_data __rcu *beacon;
	struct probe_resp __rcu *probe_resp;

261 262
	/* to be used after channel switch. */
	struct cfg80211_beacon_data *next_beacon;
263
	struct list_head vlans; /* write-protected with RTNL and local->mtx */
264 265 266

	struct ps_data ps;
	atomic_t num_mcast_sta; /* number of stations receiving multicast */
267 268 269 270
	enum ieee80211_smps_mode req_smps, /* requested smps mode */
			 driver_smps_mode; /* smps mode request */

	struct work_struct request_smps_work;
271 272
};

273 274
struct ieee80211_if_wds {
	struct sta_info *sta;
275
	u8 remote_addr[ETH_ALEN];
276 277 278
};

struct ieee80211_if_vlan {
279
	struct list_head list; /* write-protected with RTNL and local->mtx */
280 281

	/* used for all tx if the VLAN is configured to 4-addr mode */
J
Johannes Berg 已提交
282
	struct sta_info __rcu *sta;
283 284
};

285
struct mesh_stats {
286 287 288
	__u32 fwded_mcast;		/* Mesh forwarded multicast frames */
	__u32 fwded_unicast;		/* Mesh forwarded unicast frames */
	__u32 fwded_frames;		/* Mesh total forwarded frames */
289 290
	__u32 dropped_frames_ttl;	/* Not transmitted since mesh_ttl == 0*/
	__u32 dropped_frames_no_route;	/* Not transmitted, no route found */
291
	__u32 dropped_frames_congestion;/* Not forwarded due to congestion */
292 293 294 295 296 297 298 299 300 301
};

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

302 303 304 305 306
#if HZ/100 == 0
#define IEEE80211_ROC_MIN_LEFT	1
#else
#define IEEE80211_ROC_MIN_LEFT	(HZ/100)
#endif
J
Johannes Berg 已提交
307

308
struct ieee80211_roc_work {
309
	struct list_head list;
310
	struct list_head dependents;
311

312
	struct delayed_work work;
J
Johannes Berg 已提交
313 314 315

	struct ieee80211_sub_if_data *sdata;

316
	struct ieee80211_channel *chan;
J
Johannes Berg 已提交
317

318
	bool started, abort, hw_begun, notified;
319
	bool to_be_freed;
320

321
	unsigned long hw_start_time;
322

323 324
	u32 duration, req_duration;
	struct sk_buff *frame;
325
	u64 cookie, mgmt_tx_cookie;
326
	enum ieee80211_roc_type type;
327 328
};

329
/* flags used in struct ieee80211_if_managed.flags */
330
enum ieee80211_sta_flags {
J
Johannes Berg 已提交
331 332
	IEEE80211_STA_CONNECTION_POLL	= BIT(1),
	IEEE80211_STA_CONTROL_PORT	= BIT(2),
333
	IEEE80211_STA_DISABLE_HT	= BIT(4),
J
Johannes Berg 已提交
334 335
	IEEE80211_STA_CSA_RECEIVED	= BIT(5),
	IEEE80211_STA_MFP_ENABLED	= BIT(6),
K
Kalle Valo 已提交
336
	IEEE80211_STA_UAPSD_ENABLED	= BIT(7),
337
	IEEE80211_STA_NULLFUNC_ACKED	= BIT(8),
338
	IEEE80211_STA_RESET_SIGNAL_AVE	= BIT(9),
339
	IEEE80211_STA_DISABLE_40MHZ	= BIT(10),
340
	IEEE80211_STA_DISABLE_VHT	= BIT(11),
J
Johannes Berg 已提交
341 342
	IEEE80211_STA_DISABLE_80P80MHZ	= BIT(12),
	IEEE80211_STA_DISABLE_160MHZ	= BIT(13),
343
	IEEE80211_STA_DISABLE_WMM	= BIT(14),
344 345
};

J
Johannes Berg 已提交
346 347 348 349 350 351 352 353 354
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;
355
	bool timeout_started;
J
Johannes Berg 已提交
356

357 358 359
	u16 sae_trans, sae_status;
	size_t data_len;
	u8 data[];
J
Johannes Berg 已提交
360 361 362 363 364 365 366 367 368 369 370 371 372 373
};

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;
374
	bool wmm, uapsd;
375
	bool need_beacon;
J
Johannes Berg 已提交
376
	bool synced;
377
	bool timeout_started;
J
Johannes Berg 已提交
378

379 380
	u8 ap_ht_param;

381 382
	struct ieee80211_vht_cap ap_vht_cap;

J
Johannes Berg 已提交
383 384 385 386
	size_t ie_len;
	u8 ie[];
};

387
struct ieee80211_if_managed {
388
	struct timer_list timer;
J
Johannes Berg 已提交
389 390
	struct timer_list conn_mon_timer;
	struct timer_list bcn_mon_timer;
S
Sujith 已提交
391
	struct timer_list chswitch_timer;
J
Johannes Berg 已提交
392
	struct work_struct monitor_work;
S
Sujith 已提交
393
	struct work_struct chswitch_work;
394
	struct work_struct beacon_connection_loss_work;
395
	struct work_struct csa_connection_drop_work;
396

397
	unsigned long beacon_timeout;
J
Johannes Berg 已提交
398
	unsigned long probe_timeout;
399
	int probe_send_count;
400
	bool nullfunc_failed;
401
	bool connection_loss;
J
Johannes Berg 已提交
402

403
	struct cfg80211_bss *associated;
J
Johannes Berg 已提交
404 405
	struct ieee80211_mgd_auth_data *auth_data;
	struct ieee80211_mgd_assoc_data *assoc_data;
406

407
	u8 bssid[ETH_ALEN];
408

409 410
	u16 aid;

411
	bool powersave; /* powersave requested for this iface */
412
	bool broken_ap; /* AP is broken -- turn off powersave */
413
	bool have_beacon;
414
	u8 dtim_period;
415
	enum ieee80211_smps_mode req_smps, /* requested smps mode */
416 417 418
				 driver_smps_mode; /* smps mode request */

	struct work_struct request_smps_work;
419

420
	unsigned int flags;
421

422
	bool beacon_crc_valid;
423 424
	u32 beacon_crc;

425 426 427 428
	bool status_acked;
	bool status_received;
	__le16 status_fc;

429 430 431 432 433 434
	enum {
		IEEE80211_MFP_DISABLED,
		IEEE80211_MFP_OPTIONAL,
		IEEE80211_MFP_REQUIRED
	} mfp; /* management frame protection */

435 436 437 438 439 440 441 442 443 444 445 446 447 448
	/*
	 * 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;

449
	int wmm_last_param_set;
450 451

	u8 use_4addr;
452

J
Janusz Dziedzic 已提交
453
	s16 p2p_noa_index;
454

455 456 457 458 459 460 461 462 463 464 465
	/* Signal strength from the last Beacon frame in the current BSS. */
	int last_beacon_signal;

	/*
	 * Weighted average of the signal strength from Beacon frames in the
	 * current BSS. This is in units of 1/16 of the signal unit to maintain
	 * accuracy and to speed up calculations, i.e., the value need to be
	 * divided by 16 to get the actual value.
	 */
	int ave_beacon_signal;

466 467 468 469 470 471 472
	/*
	 * 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;

473 474 475 476 477 478
	/*
	 * 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;
479 480 481 482 483 484 485 486

	/*
	 * 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 已提交
487 488 489

	struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
	struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */
490 491
	struct ieee80211_vht_cap vht_capa; /* configured VHT overrides */
	struct ieee80211_vht_cap vht_capa_mask; /* Valid parts of vht_capa */
492 493
};

494 495
struct ieee80211_if_ibss {
	struct timer_list timer;
496
	struct work_struct csa_connection_drop_work;
497

498
	unsigned long last_scan_completed;
499

500 501
	u32 basic_rates;

502 503
	bool fixed_bssid;
	bool fixed_channel;
J
Johannes Berg 已提交
504
	bool privacy;
505

506
	bool control_port;
507
	bool userspace_handles_dfs;
508

509
	u8 bssid[ETH_ALEN] __aligned(2);
510 511 512
	u8 ssid[IEEE80211_MAX_SSID_LEN];
	u8 ssid_len, ie_len;
	u8 *ie;
513
	struct cfg80211_chan_def chandef;
514 515

	unsigned long ibss_join_req;
516
	/* probe response/beacon for IBSS */
517
	struct beacon_data __rcu *presp;
518

519 520 521
	struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
	struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */

522 523 524
	spinlock_t incomplete_lock;
	struct list_head incomplete_stations;

525 526 527 528 529 530
	enum {
		IEEE80211_IBSS_MLME_SEARCH,
		IEEE80211_IBSS_MLME_JOINED,
	} state;
};

531 532 533 534 535 536 537 538 539 540 541 542 543 544
/**
 * 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);
545 546 547 548

	/* should be called with beacon_data under RCU read lock */
	void (*adjust_tbtt)(struct ieee80211_sub_if_data *sdata,
			    struct beacon_data *beacon);
549 550 551
	/* add other framework functions here */
};

552 553 554 555 556
struct mesh_csa_settings {
	struct rcu_head rcu_head;
	struct cfg80211_csa_settings settings;
};

557 558 559
struct ieee80211_if_mesh {
	struct timer_list housekeeping_timer;
	struct timer_list mesh_path_timer;
560
	struct timer_list mesh_path_root_timer;
561

562
	unsigned long wrkq_flags;
563
	unsigned long mbss_changed;
564 565 566 567

	u8 mesh_id[IEEE80211_MAX_MESH_ID_LEN];
	size_t mesh_id_len;
	/* Active Path Selection Protocol Identifier */
R
Rui Paulo 已提交
568
	u8 mesh_pp_id;
569
	/* Active Path Selection Metric Identifier */
R
Rui Paulo 已提交
570
	u8 mesh_pm_id;
571
	/* Congestion Control Mode Identifier */
R
Rui Paulo 已提交
572
	u8 mesh_cc_id;
573
	/* Synchronization Protocol Identifier */
R
Rui Paulo 已提交
574
	u8 mesh_sp_id;
575
	/* Authentication Protocol Identifier */
R
Rui Paulo 已提交
576
	u8 mesh_auth_id;
577 578
	/* Local mesh Sequence Number */
	u32 sn;
579 580 581
	/* Last used PREQ ID */
	u32 preq_id;
	atomic_t mpaths;
582 583
	/* Timestamp of last SN update */
	unsigned long last_sn_update;
584 585 586
	/* Time when it's ok to send next PERR */
	unsigned long next_perr;
	/* Timestamp of last PREQ sent */
587 588 589 590 591 592 593
	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;
594
	atomic_t estab_plinks;
595 596
	u32 mesh_seqnum;
	bool accepting_plinks;
597
	int num_gates;
T
Thomas Pedersen 已提交
598
	struct beacon_data __rcu *beacon;
599 600
	const u8 *ie;
	u8 ie_len;
601 602 603 604 605
	enum {
		IEEE80211_MESH_SEC_NONE = 0x0,
		IEEE80211_MESH_SEC_AUTHED = 0x1,
		IEEE80211_MESH_SEC_SECURED = 0x2,
	} security;
606
	bool user_mpm;
607
	/* Extensible Synchronization Framework */
608
	const struct ieee80211_mesh_sync_ops *sync_ops;
609 610 611
	s64 sync_offset_clockdrift_max;
	spinlock_t sync_offset_lock;
	bool adjusting_tbtt;
M
Marco Porsch 已提交
612 613 614 615 616
	/* mesh power save */
	enum nl80211_mesh_power_mode nonpeer_pm;
	int ps_peers_light_sleep;
	int ps_peers_deep_sleep;
	struct ps_data ps;
617
	/* Channel Switching Support */
618
	struct mesh_csa_settings __rcu *csa;
619 620 621 622 623
	enum {
		IEEE80211_MESH_CSA_ROLE_NONE,
		IEEE80211_MESH_CSA_ROLE_INIT,
		IEEE80211_MESH_CSA_ROLE_REPEATER,
	} csa_role;
624
	u8 chsw_ttl;
625
	u16 pre_value;
626 627 628

	/* offset from skb->data while building IE */
	int meshconf_offset;
629
};
J
Johannes Berg 已提交
630 631

#ifdef CONFIG_MAC80211_MESH
632 633
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name)	\
	do { (msh)->mshstats.name++; } while (0)
J
Johannes Berg 已提交
634
#else
635
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \
J
Johannes Berg 已提交
636 637
	do { } while (0)
#endif
638

639 640 641 642 643 644 645 646 647
/**
 * enum ieee80211_sub_if_data_flags - virtual interface flags
 *
 * @IEEE80211_SDATA_ALLMULTI: interface wants all multicast packets
 * @IEEE80211_SDATA_PROMISC: interface is promisc
 * @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.
648
 * @IEEE80211_SDATA_DISCONNECT_RESUME: Disconnect after resume.
649
 * @IEEE80211_SDATA_IN_DRIVER: indicates interface was added to driver
650 651 652 653
 */
enum ieee80211_sub_if_data_flags {
	IEEE80211_SDATA_ALLMULTI		= BIT(0),
	IEEE80211_SDATA_PROMISC			= BIT(1),
654 655
	IEEE80211_SDATA_OPERATING_GMODE		= BIT(2),
	IEEE80211_SDATA_DONT_BRIDGE_PACKETS	= BIT(3),
656
	IEEE80211_SDATA_DISCONNECT_RESUME	= BIT(4),
657
	IEEE80211_SDATA_IN_DRIVER		= BIT(5),
658 659
};

660 661 662 663 664
/**
 * 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
665 666
 * @SDATA_STATE_OFFCHANNEL: This interface is currently in offchannel
 *	mode, so queues are stopped
667 668
 * @SDATA_STATE_OFFCHANNEL_BEACON_STOPPED: Beaconing was stopped due
 *	to offchannel, reset when offchannel returns
669 670 671
 */
enum ieee80211_sdata_state_bits {
	SDATA_STATE_RUNNING,
672
	SDATA_STATE_OFFCHANNEL,
673
	SDATA_STATE_OFFCHANNEL_BEACON_STOPPED,
674 675
};

676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693
/**
 * 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
};

struct ieee80211_chanctx {
	struct list_head list;
	struct rcu_head rcu_head;

694
	struct list_head assigned_vifs;
695
	struct list_head reserved_vifs;
696

697
	enum ieee80211_chanctx_mode mode;
698
	bool driver_present;
699 700 701 702

	struct ieee80211_chanctx_conf conf;
};

703 704 705 706 707
struct mac80211_qos_map {
	struct cfg80211_qos_map qos_map;
	struct rcu_head rcu_head;
};

708 709 710 711 712
struct ieee80211_sub_if_data {
	struct list_head list;

	struct wireless_dev wdev;

J
Johannes Berg 已提交
713 714 715
	/* keys */
	struct list_head key_list;

716 717
	/* count for keys needing tailroom space allocation */
	int crypto_tx_tailroom_needed_cnt;
718 719
	int crypto_tx_tailroom_pending_dec;
	struct delayed_work dec_tailroom_needed_wk;
720

721 722 723
	struct net_device *dev;
	struct ieee80211_local *local;

724
	unsigned int flags;
725

726 727
	unsigned long state;

728 729
	int drop_unencrypted;

730 731
	char name[IFNAMSIZ];

732 733 734 735
	/* Fragment table for host-based reassembly */
	struct ieee80211_fragment_entry	fragments[IEEE80211_FRAGMENT_MAX];
	unsigned int fragment_next;

736 737 738
	/* TID bitmap for NoAck policy */
	u16 noack_map;

Y
Yoni Divinsky 已提交
739 740 741
	/* bit field of ACM bits (BIT(802.1D tag)) */
	u8 wmm_acm;

J
Johannes Berg 已提交
742 743 744 745
	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;
746

J
Johannes Berg 已提交
747
	u16 sequence_number;
748 749
	__be16 control_port_protocol;
	bool control_port_no_encrypt;
750
	int encrypt_headroom;
J
Johannes Berg 已提交
751

752
	struct ieee80211_tx_queue_params tx_conf[IEEE80211_NUM_ACS];
753
	struct mac80211_qos_map __rcu *qos_map;
754

755
	struct work_struct csa_finalize_work;
756 757
	u16 csa_counter_offset_beacon[IEEE80211_MAX_CSA_COUNTERS_NUM];
	u16 csa_counter_offset_presp[IEEE80211_MAX_CSA_COUNTERS_NUM];
758
	bool csa_radar_required;
759
	bool csa_block_tx; /* write-protected by sdata_lock and local->mtx */
760
	struct cfg80211_chan_def csa_chandef;
761

762
	struct list_head assigned_chanctx_list; /* protected by chanctx_mtx */
763
	struct list_head reserved_chanctx_list; /* protected by chanctx_mtx */
764

765 766 767
	/* context reservation -- protected with chanctx_mtx */
	struct ieee80211_chanctx *reserved_chanctx;
	struct cfg80211_chan_def reserved_chandef;
768
	bool reserved_radar_required;
769
	u8 csa_current_counter;
770

771 772 773
	/* used to reconfigure hardware SM PS */
	struct work_struct recalc_smps;

J
Johannes Berg 已提交
774
	struct work_struct work;
J
Johannes Berg 已提交
775 776
	struct sk_buff_head skb_queue;

777 778 779
	u8 needed_rx_chains;
	enum ieee80211_smps_mode smps_mode;

780 781 782
	int user_power_level; /* in dBm */
	int ap_power_level; /* in dBm */

783 784 785
	bool radar_required;
	struct delayed_work dfs_cac_timer_work;

786
	/*
787 788 789
	 * AP this belongs to: self in AP mode and
	 * corresponding AP in VLAN mode, NULL for
	 * all others (might be needed later in IBSS)
790
	 */
791 792
	struct ieee80211_if_ap *bss;

793 794
	/* bitmap of allowed (non-MCS) rate indexes for rate control */
	u32 rc_rateidx_mask[IEEE80211_NUM_BANDS];
795 796

	bool rc_has_mcs_mask[IEEE80211_NUM_BANDS];
797
	u8  rc_rateidx_mcs_mask[IEEE80211_NUM_BANDS][IEEE80211_HT_MCS_MASK_LEN];
798 799 800 801 802

	union {
		struct ieee80211_if_ap ap;
		struct ieee80211_if_wds wds;
		struct ieee80211_if_vlan vlan;
803 804
		struct ieee80211_if_managed mgd;
		struct ieee80211_if_ibss ibss;
805
		struct ieee80211_if_mesh mesh;
806
		u32 mntr_flags;
807
	} u;
J
Jiri Benc 已提交
808 809

#ifdef CONFIG_MAC80211_DEBUGFS
810
	struct {
811
		struct dentry *subdir_stations;
812 813
		struct dentry *default_unicast_key;
		struct dentry *default_multicast_key;
814
		struct dentry *default_mgmt_key;
815
	} debugfs;
J
Jiri Benc 已提交
816
#endif
817

818 819
	/* must be last, dynamically sized area in this! */
	struct ieee80211_vif vif;
820 821
};

822 823 824 825 826 827
static inline
struct ieee80211_sub_if_data *vif_to_sdata(struct ieee80211_vif *p)
{
	return container_of(p, struct ieee80211_sub_if_data, vif);
}

828 829 830 831 832 833 834 835 836 837 838 839 840 841
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);
}

842 843 844
#define sdata_dereference(p, sdata) \
	rcu_dereference_protected(p, lockdep_is_held(&sdata->wdev.mtx))

845 846 847 848 849 850
static inline void
sdata_assert_lock(struct ieee80211_sub_if_data *sdata)
{
	lockdep_assert_held(&sdata->wdev.mtx);
}

J
Johannes Berg 已提交
851 852 853 854 855 856 857 858 859
static inline enum ieee80211_band
ieee80211_get_sdata_band(struct ieee80211_sub_if_data *sdata)
{
	enum ieee80211_band band = IEEE80211_BAND_2GHZ;
	struct ieee80211_chanctx_conf *chanctx_conf;

	rcu_read_lock();
	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
	if (!WARN_ON(!chanctx_conf))
860
		band = chanctx_conf->def.chan->band;
J
Johannes Berg 已提交
861 862 863 864 865
	rcu_read_unlock();

	return band;
}

866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893
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;
}

894 895 896 897 898 899
enum sdata_queue_type {
	IEEE80211_SDATA_QUEUE_TYPE_FRAME	= 0,
	IEEE80211_SDATA_QUEUE_AGG_START		= 1,
	IEEE80211_SDATA_QUEUE_AGG_STOP		= 2,
};

900 901 902 903 904
enum {
	IEEE80211_RX_MSG	= 1,
	IEEE80211_TX_STATUS_MSG	= 2,
};

K
Kalle Valo 已提交
905 906
enum queue_stop_reason {
	IEEE80211_QUEUE_STOP_REASON_DRIVER,
907
	IEEE80211_QUEUE_STOP_REASON_PS,
908 909
	IEEE80211_QUEUE_STOP_REASON_CSA,
	IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
910
	IEEE80211_QUEUE_STOP_REASON_SUSPEND,
911
	IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
912
	IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL,
913
	IEEE80211_QUEUE_STOP_REASON_FLUSH,
K
Kalle Valo 已提交
914 915
};

916
#ifdef CONFIG_MAC80211_LEDS
917 918 919 920 921 922 923 924
struct tpt_led_trigger {
	struct led_trigger trig;
	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;
925 926
	unsigned int active, want;
	bool running;
927
};
928
#endif
929

930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947
/*
 * struct ieee80211_tx_latency_bin_ranges - Tx latency statistics bins ranges
 *
 * Measuring Tx latency statistics. Counts how many Tx frames transmitted in a
 * certain latency range (in Milliseconds). Each station that uses these
 * ranges will have bins to count the amount of frames received in that range.
 * The user can configure the ranges via debugfs.
 * If ranges is NULL then Tx latency statistics bins are disabled for all
 * stations.
 *
 * @n_ranges: number of ranges that are taken in account
 * @ranges: the ranges that the user requested or NULL if disabled.
 */
struct ieee80211_tx_latency_bin_ranges {
	int n_ranges;
	u32 ranges[];
};

948 949 950 951 952 953 954
/**
 * 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
955 956
 * @SCAN_ONCHANNEL_SCANNING:  Do a software scan on only the current operating
 *	channel. This should not interrupt normal traffic.
957 958 959 960
 * @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.
961 962
 * @SCAN_HW_CANCELLED: Set for our scan work function when the scan is being
 *	cancelled.
963
 */
964 965
enum {
	SCAN_SW_SCANNING,
966
	SCAN_HW_SCANNING,
967
	SCAN_ONCHANNEL_SCANNING,
968 969
	SCAN_COMPLETED,
	SCAN_ABORTED,
970
	SCAN_HW_CANCELLED,
971 972 973 974 975 976 977 978 979 980
};

/**
 * 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
981 982 983
 * @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
984
 * @SCAN_ABORT: Abort the scan and go back to operating channel
985 986 987 988 989
 */
enum mac80211_scan_state {
	SCAN_DECISION,
	SCAN_SET_CHANNEL,
	SCAN_SEND_PROBE,
990 991
	SCAN_SUSPEND,
	SCAN_RESUME,
992
	SCAN_ABORT,
993 994
};

995 996 997 998 999 1000 1001 1002
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;

	const struct ieee80211_ops *ops;

1003 1004 1005 1006 1007 1008
	/*
	 * private workqueue to mac80211. mac80211 makes this accessible
	 * via ieee80211_queue_work()
	 */
	struct workqueue_struct *workqueue;

1009
	unsigned long queue_stop_reasons[IEEE80211_MAX_QUEUES];
1010
	/* also used to protect ampdu_ac_queue and amdpu_ac_stop_refcnt */
K
Kalle Valo 已提交
1011
	spinlock_t queue_stop_reason_lock;
1012

1013
	int open_count;
1014
	int monitors, cooked_mntrs;
1015
	/* number of interfaces with corresponding FIF_ flags */
1016 1017 1018
	int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss, fif_pspoll,
	    fif_probe_req;
	int probe_req_reg;
1019
	unsigned int filter_flags; /* FIF_* */
J
Johannes Berg 已提交
1020

1021 1022
	bool wiphy_ciphers_allocated;

1023 1024
	bool use_chanctx;

J
Johannes Berg 已提交
1025 1026 1027
	/* protects the aggregated multicast list and filter calls */
	spinlock_t filter_lock;

1028 1029 1030
	/* used for uploading changed mc list */
	struct work_struct reconfig_filter;

J
Johannes Berg 已提交
1031
	/* aggregated multicast list */
1032
	struct netdev_hw_addr_list mc_list;
J
Johannes Berg 已提交
1033

1034
	bool tim_in_locked_section; /* see ieee80211_beacon_get() */
1035 1036 1037 1038 1039 1040 1041 1042 1043

	/*
	 * 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 已提交
1044 1045 1046 1047 1048 1049 1050 1051
	/*
	 * 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;

1052 1053 1054 1055 1056 1057
	/*
	 * quiescing is true during the suspend process _only_ to
	 * ease timer cancelling etc.
	 */
	bool quiescing;

1058 1059 1060
	/* device is started */
	bool started;

1061 1062 1063
	/* device is during a HW reconfig */
	bool in_reconfig;

1064 1065 1066
	/* wowlan is enabled -- don't reconfig on resume */
	bool wowlan;

1067 1068 1069 1070
	/* DFS/radar detection is enabled */
	bool radar_detect_enabled;
	struct work_struct radar_detected_work;

1071 1072 1073
	/* number of RX chains the hardware has */
	u8 rx_chains;

1074
	int tx_headroom; /* required headroom for hardware/radiotap */
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084

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

1085
	spinlock_t rx_path_lock;
1086

1087 1088
	/* Station data */
	/*
1089 1090
	 * The mutex only protects the list, hash table and
	 * counter, reads are done with RCU.
1091
	 */
1092
	struct mutex sta_mtx;
1093
	spinlock_t tim_lock;
1094
	unsigned long num_sta;
1095
	struct list_head sta_list;
J
Johannes Berg 已提交
1096
	struct sta_info __rcu *sta_hash[STA_HASH_SIZE];
1097
	struct timer_list sta_cleanup;
1098
	int sta_generation;
1099

1100 1101 1102 1103 1104 1105
	/*
	 * Tx latency statistics parameters for all stations.
	 * Can enable via debugfs (NULL when disabled).
	 */
	struct ieee80211_tx_latency_bin_ranges __rcu *tx_latency;

1106
	struct sk_buff_head pending[IEEE80211_MAX_QUEUES];
1107 1108
	struct tasklet_struct tx_pending_tasklet;

1109
	atomic_t agg_queue_stop[IEEE80211_MAX_QUEUES];
1110

1111 1112
	/* number of interfaces with corresponding IFF_ flags */
	atomic_t iff_allmultis, iff_promiscs;
1113 1114 1115

	struct rate_control_ref *rate_ctrl;

1116 1117
	struct crypto_cipher *wep_tx_tfm;
	struct crypto_cipher *wep_rx_tfm;
1118 1119
	u32 wep_iv;

1120
	/* see iface.c */
1121
	struct list_head interfaces;
1122
	struct mutex iflist_mtx;
1123

J
Johannes Berg 已提交
1124
	/*
J
Johannes Berg 已提交
1125
	 * Key mutex, protects sdata's key_list and sta_info's
J
Johannes Berg 已提交
1126 1127
	 * key pointers (write access, they're RCU.)
	 */
J
Johannes Berg 已提交
1128
	struct mutex key_mtx;
J
Johannes Berg 已提交
1129

1130 1131
	/* mutex for scan and work locking */
	struct mutex mtx;
J
Johannes Berg 已提交
1132

1133
	/* Scanning and BSS list */
1134
	unsigned long scanning;
1135
	struct cfg80211_ssid scan_ssid;
1136
	struct cfg80211_scan_request *int_scan_req;
1137
	struct cfg80211_scan_request *scan_req, *hw_scan_req;
1138
	struct cfg80211_chan_def scan_chandef;
1139
	enum ieee80211_band hw_scan_band;
1140
	int scan_channel_idx;
1141
	int scan_ies_len;
1142
	int hw_scan_ies_bufsize;
1143

1144
	struct work_struct sched_scan_stopped_work;
1145
	struct ieee80211_sub_if_data __rcu *sched_scan_sdata;
1146
	struct cfg80211_sched_scan_request *sched_scan_req;
1147

1148
	unsigned long leave_oper_channel_time;
1149
	enum mac80211_scan_state next_scan_state;
1150
	struct delayed_work scan_work;
1151
	struct ieee80211_sub_if_data __rcu *scan_sdata;
J
Johannes Berg 已提交
1152
	/* For backward compatibility only -- do not use */
1153
	struct cfg80211_chan_def _oper_chandef;
1154

1155 1156 1157
	/* Temporary remain-on-channel for off-channel operations */
	struct ieee80211_channel *tmp_channel;

1158 1159 1160 1161
	/* channel contexts */
	struct list_head chanctx_list;
	struct mutex chanctx_mtx;

1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174
	/* SNMP counters */
	/* dot11CountersTable */
	u32 dot11TransmittedFragmentCount;
	u32 dot11MulticastTransmittedFrameCount;
	u32 dot11FailedCount;
	u32 dot11RetryCount;
	u32 dot11MultipleRetryCount;
	u32 dot11FrameDuplicateCount;
	u32 dot11ReceivedFragmentCount;
	u32 dot11MulticastReceivedFrameCount;
	u32 dot11TransmittedFrameCount;

#ifdef CONFIG_MAC80211_LEDS
I
Ivo van Doorn 已提交
1175
	struct led_trigger *tx_led, *rx_led, *assoc_led, *radio_led;
1176
	struct tpt_led_trigger *tpt_led_trigger;
I
Ivo van Doorn 已提交
1177 1178
	char tx_led_name[32], rx_led_name[32],
	     assoc_led_name[32], radio_led_name[32];
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
#endif

#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
	/* TX/RX handler statistics */
	unsigned int tx_handlers_drop;
	unsigned int tx_handlers_queued;
	unsigned int tx_handlers_drop_unencrypted;
	unsigned int tx_handlers_drop_fragment;
	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 rx_handlers_drop_short;
	unsigned int tx_expand_skb_head;
	unsigned int tx_expand_skb_head_cloned;
	unsigned int rx_expand_skb_head;
	unsigned int rx_expand_skb_head2;
	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
				*/
1210

1211
	bool pspolling;
1212
	bool offchannel_ps_enabled;
1213 1214 1215 1216 1217
	/*
	 * 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;
1218 1219 1220
	struct work_struct dynamic_ps_enable_work;
	struct work_struct dynamic_ps_disable_work;
	struct timer_list dynamic_ps_timer;
1221
	struct notifier_block network_latency_notifier;
1222
	struct notifier_block ifa_notifier;
1223
	struct notifier_block ifa6_notifier;
1224

1225 1226 1227 1228 1229 1230
	/*
	 * The dynamic ps timeout configured from user space via WEXT -
	 * this will override whatever chosen by mac80211 internally.
	 */
	int dynamic_ps_forced_timeout;

1231
	int user_power_level; /* in dBm, for all interfaces */
1232

1233 1234
	enum ieee80211_smps_mode smps_mode;

1235 1236
	struct work_struct restart_work;

J
Jiri Benc 已提交
1237 1238
#ifdef CONFIG_MAC80211_DEBUGFS
	struct local_debugfsdentries {
1239
		struct dentry *rcdir;
J
Jiri Benc 已提交
1240 1241 1242
		struct dentry *keys;
	} debugfs;
#endif
1243

1244 1245 1246 1247
	/*
	 * Remain-on-channel support
	 */
	struct list_head roc_list;
1248
	struct work_struct hw_roc_start, hw_roc_done;
1249
	unsigned long hw_roc_start_time;
1250
	u64 roc_cookie_counter;
1251

J
Johannes Berg 已提交
1252 1253 1254
	struct idr ack_status_frames;
	spinlock_t ack_status_lock;

1255 1256
	struct ieee80211_sub_if_data __rcu *p2p_sdata;

J
Johannes Berg 已提交
1257 1258
	struct napi_struct *napi;

1259 1260
	/* virtual monitor interface */
	struct ieee80211_sub_if_data __rcu *monitor_sdata;
1261
	struct cfg80211_chan_def monitor_chandef;
1262 1263
};

1264 1265 1266 1267 1268 1269
static inline struct ieee80211_sub_if_data *
IEEE80211_DEV_TO_SUB_IF(struct net_device *dev)
{
	return netdev_priv(dev);
}

1270 1271 1272 1273 1274 1275
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);
}

1276
/* this struct represents 802.11n's RA/TID combination */
1277 1278 1279 1280 1281
struct ieee80211_ra_tid {
	u8 ra[ETH_ALEN];
	u16 tid;
};

1282 1283 1284 1285 1286 1287
/* 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;
1288
	u16 pre_value;
1289 1290
};

1291 1292
/* Parsed Information Elements */
struct ieee802_11_elems {
J
Johannes Berg 已提交
1293
	const u8 *ie_start;
1294 1295 1296
	size_t total_len;

	/* pointers to IEs */
J
Johannes Berg 已提交
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
	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;
1320
	const struct ieee80211_ext_chansw_ie *ext_chansw_ie;
1321
	const struct ieee80211_wide_bw_chansw_ie *wide_bw_chansw_ie;
J
Johannes Berg 已提交
1322 1323
	const u8 *country_elem;
	const u8 *pwr_constr_elem;
1324
	const struct ieee80211_timeout_interval_ie *timeout_int;
J
Johannes Berg 已提交
1325
	const u8 *opmode_notif;
1326
	const struct ieee80211_sec_chan_offs_ie *sec_chan_offs;
1327
	const struct ieee80211_mesh_chansw_params_ie *mesh_chansw_params_ie;
1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343

	/* length of them, respectively */
	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 已提交
1344 1345 1346

	/* whether a parse error occurred while retrieving these elements */
	bool parse_error;
1347 1348
};

1349 1350 1351 1352 1353 1354 1355
static inline struct ieee80211_local *hw_to_local(
	struct ieee80211_hw *hw)
{
	return container_of(hw, struct ieee80211_local, hw);
}


1356 1357
static inline int ieee80211_bssid_match(const u8 *raddr, const u8 *addr)
{
1358
	return ether_addr_equal(raddr, addr) ||
1359 1360 1361
	       is_broadcast_ether_addr(raddr);
}

1362 1363 1364 1365 1366 1367 1368
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);
	return status->flag & (RX_FLAG_MACTIME_START | RX_FLAG_MACTIME_END);
}
1369

1370 1371 1372 1373
u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
				     struct ieee80211_rx_status *status,
				     unsigned int mpdu_len,
				     unsigned int mpdu_offset);
1374
int ieee80211_hw_config(struct ieee80211_local *local, u32 changed);
1375
void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx);
J
Johannes Berg 已提交
1376 1377
void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
				      u32 changed);
1378
void ieee80211_configure_filter(struct ieee80211_local *local);
1379
u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata);
1380

1381
/* STA code */
J
Johannes Berg 已提交
1382
void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata);
1383 1384 1385 1386 1387
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,
1388
			 struct cfg80211_deauth_request *req);
1389
int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
1390
			   struct cfg80211_disassoc_request *req);
1391 1392
void ieee80211_send_pspoll(struct ieee80211_local *local,
			   struct ieee80211_sub_if_data *sdata);
1393
void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency);
E
Eliad Peller 已提交
1394
void ieee80211_recalc_ps_vif(struct ieee80211_sub_if_data *sdata);
1395 1396
int ieee80211_max_network_latency(struct notifier_block *nb,
				  unsigned long data, void *dummy);
1397
int ieee80211_set_arp_filter(struct ieee80211_sub_if_data *sdata);
1398 1399 1400
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);
1401
void ieee80211_sta_reset_beacon_monitor(struct ieee80211_sub_if_data *sdata);
1402
void ieee80211_sta_reset_conn_monitor(struct ieee80211_sub_if_data *sdata);
1403
void ieee80211_mgd_stop(struct ieee80211_sub_if_data *sdata);
1404 1405
void ieee80211_mgd_conn_tx_status(struct ieee80211_sub_if_data *sdata,
				  __le16 fc, bool acked);
1406
void ieee80211_mgd_quiesce(struct ieee80211_sub_if_data *sdata);
1407
void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata);
J
Johannes Berg 已提交
1408

1409 1410 1411
/* IBSS code */
void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local);
void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata);
1412 1413
void ieee80211_ibss_rx_no_sta(struct ieee80211_sub_if_data *sdata,
			      const u8 *bssid, const u8 *addr, u32 supp_rates);
1414 1415 1416
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);
1417 1418 1419
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);
1420 1421 1422 1423
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);
1424 1425 1426 1427 1428

/* 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);
1429
int ieee80211_mesh_csa_beacon(struct ieee80211_sub_if_data *sdata,
1430
			      struct cfg80211_csa_settings *csa_settings);
1431
int ieee80211_mesh_finish_csa(struct ieee80211_sub_if_data *sdata);
1432

J
Johannes Berg 已提交
1433
/* scan/BSS handling */
1434
void ieee80211_scan_work(struct work_struct *work);
S
Stanislaw Gruszka 已提交
1435 1436
int ieee80211_request_ibss_scan(struct ieee80211_sub_if_data *sdata,
				const u8 *ssid, u8 ssid_len,
1437 1438
				struct ieee80211_channel *chan,
				enum nl80211_bss_scan_width scan_width);
1439
int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
1440
			   struct cfg80211_scan_request *req);
1441
void ieee80211_scan_cancel(struct ieee80211_local *local);
1442
void ieee80211_run_deferred_scan(struct ieee80211_local *local);
J
Johannes Berg 已提交
1443
void ieee80211_scan_rx(struct ieee80211_local *local, struct sk_buff *skb);
J
Johannes Berg 已提交
1444

1445
void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local);
1446
struct ieee80211_bss *
1447 1448 1449 1450 1451
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,
1452
			  struct ieee80211_channel *channel);
1453
void ieee80211_rx_bss_put(struct ieee80211_local *local,
1454
			  struct ieee80211_bss *bss);
1455

1456
/* scheduled scan handling */
1457 1458 1459
int
__ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
				     struct cfg80211_sched_scan_request *req);
1460 1461
int ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
				       struct cfg80211_sched_scan_request *req);
1462
int ieee80211_request_sched_scan_stop(struct ieee80211_sub_if_data *sdata);
1463
void ieee80211_sched_scan_end(struct ieee80211_local *local);
1464
void ieee80211_sched_scan_stopped_work(struct work_struct *work);
1465

1466
/* off-channel helpers */
1467 1468
void ieee80211_offchannel_stop_vifs(struct ieee80211_local *local);
void ieee80211_offchannel_return(struct ieee80211_local *local);
1469 1470
void ieee80211_roc_setup(struct ieee80211_local *local);
void ieee80211_start_next_roc(struct ieee80211_local *local);
1471 1472
void ieee80211_roc_purge(struct ieee80211_local *local,
			 struct ieee80211_sub_if_data *sdata);
1473
void ieee80211_roc_notify_destroy(struct ieee80211_roc_work *roc, bool free);
1474 1475
void ieee80211_sw_roc_work(struct work_struct *work);
void ieee80211_handle_roc_started(struct ieee80211_roc_work *roc);
1476

1477
/* channel switch handling */
1478
bool ieee80211_csa_needs_block_tx(struct ieee80211_local *local);
1479
void ieee80211_csa_finalize_work(struct work_struct *work);
1480 1481
int ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
			     struct cfg80211_csa_settings *params);
1482

1483
/* interface handling */
1484 1485
int ieee80211_iface_init(void);
void ieee80211_iface_exit(void);
1486
int ieee80211_if_add(struct ieee80211_local *local, const char *name,
1487
		     struct wireless_dev **new_wdev, enum nl80211_iftype type,
1488
		     struct vif_params *params);
1489
int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
1490
			     enum nl80211_iftype type);
1491
void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata);
1492
void ieee80211_remove_interfaces(struct ieee80211_local *local);
1493
u32 ieee80211_idle_off(struct ieee80211_local *local);
J
Johannes Berg 已提交
1494
void ieee80211_recalc_idle(struct ieee80211_local *local);
1495 1496
void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
				    const int offset);
1497 1498
int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up);
void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata);
1499 1500
int ieee80211_add_virtual_monitor(struct ieee80211_local *local);
void ieee80211_del_virtual_monitor(struct ieee80211_local *local);
1501

1502 1503 1504
bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata);
void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata);

1505 1506
static inline bool ieee80211_sdata_running(struct ieee80211_sub_if_data *sdata)
{
1507
	return test_bit(SDATA_STATE_RUNNING, &sdata->state);
1508 1509
}

1510 1511 1512
/* tx handling */
void ieee80211_clear_tx_pending(struct ieee80211_local *local);
void ieee80211_tx_pending(unsigned long data);
1513 1514 1515 1516
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);
1517 1518
void ieee80211_purge_tx_queue(struct ieee80211_hw *hw,
			      struct sk_buff_head *skbs);
1519

1520
/* HT */
B
Ben Greear 已提交
1521 1522
void ieee80211_apply_htcap_overrides(struct ieee80211_sub_if_data *sdata,
				     struct ieee80211_sta_ht_cap *ht_cap);
1523
bool ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_sub_if_data *sdata,
B
Ben Greear 已提交
1524
				       struct ieee80211_supported_band *sband,
J
Johannes Berg 已提交
1525
				       const struct ieee80211_ht_cap *ht_cap_ie,
1526
				       struct sta_info *sta);
J
Johannes Berg 已提交
1527 1528 1529
void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata,
			  const u8 *da, u16 tid,
			  u16 initiator, u16 reason_code);
1530 1531 1532
int ieee80211_send_smps_action(struct ieee80211_sub_if_data *sdata,
			       enum ieee80211_smps_mode smps, const u8 *da,
			       const u8 *bssid);
1533 1534 1535 1536
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);
1537

1538
void ___ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
1539
				     u16 initiator, u16 reason, bool stop);
1540
void __ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
1541
				    u16 initiator, u16 reason, bool stop);
1542 1543
void ieee80211_sta_tear_down_BA_sessions(struct sta_info *sta,
					 enum ieee80211_agg_stop_reason reason);
1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
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);

1556
int __ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
1557
				   enum ieee80211_agg_stop_reason reason);
J
Johannes Berg 已提交
1558
int ___ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
1559
				    enum ieee80211_agg_stop_reason reason);
1560 1561
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 已提交
1562 1563
void ieee80211_ba_session_work(struct work_struct *work);
void ieee80211_tx_ba_session_handle_start(struct sta_info *sta, int tid);
1564
void ieee80211_release_reorder_timeout(struct sta_info *sta, int tid);
1565

1566 1567
u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs);

M
Mahesh Palivela 已提交
1568
/* VHT */
J
Johannes Berg 已提交
1569 1570 1571 1572 1573
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);
1574
enum ieee80211_sta_rx_bandwidth ieee80211_sta_cur_vht_bw(struct sta_info *sta);
1575
void ieee80211_sta_set_rx_nss(struct sta_info *sta);
1576 1577 1578
u32 __ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
                                  struct sta_info *sta, u8 opmode,
                                  enum ieee80211_band band, bool nss_only);
1579 1580
void ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
				 struct sta_info *sta, u8 opmode,
1581
				 enum ieee80211_band band, bool nss_only);
1582 1583
void ieee80211_apply_vhtcap_overrides(struct ieee80211_sub_if_data *sdata,
				      struct ieee80211_sta_vht_cap *vht_cap);
1584

1585 1586 1587 1588
/* Spectrum management */
void ieee80211_process_measurement_req(struct ieee80211_sub_if_data *sdata,
				       struct ieee80211_mgmt *mgmt,
				       size_t len);
1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
/**
 * 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
 * @beacon: indicates if the frame was a beacon or probe response
 * @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)
1602 1603
 * @csa_ie: parsed 802.11 csa elements on count, mode, chandef and mesh ttl.
	All of them will be filled with if success only.
1604 1605 1606 1607 1608
 * 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,
				 struct ieee802_11_elems *elems, bool beacon,
				 enum ieee80211_band current_band,
1609 1610
				 u32 sta_flags, u8 *bssid,
				 struct ieee80211_csa_ie *csa_ie);
1611

1612 1613
/* Suspend/resume and hw reconfiguration */
int ieee80211_reconfig(struct ieee80211_local *local);
1614
void ieee80211_stop_device(struct ieee80211_local *local);
1615

1616 1617
int __ieee80211_suspend(struct ieee80211_hw *hw,
			struct cfg80211_wowlan *wowlan);
1618 1619 1620

static inline int __ieee80211_resume(struct ieee80211_hw *hw)
{
1621 1622 1623 1624 1625 1626
	struct ieee80211_local *local = hw_to_local(hw);

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

1627 1628
	return ieee80211_reconfig(hw_to_local(hw));
}
1629

J
Johannes Berg 已提交
1630
/* utility functions/constants */
1631
extern const void *const mac80211_wiphy_privid; /* for wiphy privid */
1632
u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
1633
			enum nl80211_iftype type);
1634
int ieee80211_frame_duration(enum ieee80211_band band, size_t len,
1635 1636
			     int rate, int erp, int short_preamble,
			     int shift);
1637
void mac80211_ev_michael_mic_failure(struct ieee80211_sub_if_data *sdata, int keyidx,
1638 1639
				     struct ieee80211_hdr *hdr, const u8 *tsc,
				     gfp_t gfp);
1640 1641
void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
			       bool bss_notify);
J
Johannes Berg 已提交
1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657
void ieee80211_xmit(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
		    enum ieee80211_band band);

void __ieee80211_tx_skb_tid_band(struct ieee80211_sub_if_data *sdata,
				 struct sk_buff *skb, int tid,
				 enum ieee80211_band band);

static inline void
ieee80211_tx_skb_tid_band(struct ieee80211_sub_if_data *sdata,
			  struct sk_buff *skb, int tid,
			  enum ieee80211_band band)
{
	rcu_read_lock();
	__ieee80211_tx_skb_tid_band(sdata, skb, tid, band);
	rcu_read_unlock();
}
1658

J
Johannes Berg 已提交
1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672
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,
1673
				    chanctx_conf->def.chan->band);
J
Johannes Berg 已提交
1674 1675 1676 1677
	rcu_read_unlock();
}

static inline void ieee80211_tx_skb(struct ieee80211_sub_if_data *sdata,
1678 1679 1680 1681 1682 1683
				    struct sk_buff *skb)
{
	/* Send all internal mgmt frames on VO. Accordingly set TID to 7. */
	ieee80211_tx_skb_tid(sdata, skb, 7);
}

1684
u32 ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
1685 1686
			       struct ieee802_11_elems *elems,
			       u64 filter, u32 crc);
1687 1688
static inline void ieee802_11_parse_elems(const u8 *start, size_t len,
					  bool action,
1689 1690
					  struct ieee802_11_elems *elems)
{
1691
	ieee802_11_parse_elems_crc(start, len, action, elems, 0, 0);
1692 1693
}

1694 1695 1696
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);
1697 1698 1699
void ieee80211_send_nullfunc(struct ieee80211_local *local,
			     struct ieee80211_sub_if_data *sdata,
			     int powersave);
1700 1701
void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
			     struct ieee80211_hdr *hdr);
1702
void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata,
1703
			     struct ieee80211_hdr *hdr, bool ack);
1704

K
Kalle Valo 已提交
1705
void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
1706
				     unsigned long queues,
K
Kalle Valo 已提交
1707 1708
				     enum queue_stop_reason reason);
void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
1709
				     unsigned long queues,
K
Kalle Valo 已提交
1710
				     enum queue_stop_reason reason);
1711 1712 1713 1714
void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
				    enum queue_stop_reason reason);
void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
				    enum queue_stop_reason reason);
1715
void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue);
1716 1717
void ieee80211_add_pending_skb(struct ieee80211_local *local,
			       struct sk_buff *skb);
1718 1719
void ieee80211_add_pending_skbs(struct ieee80211_local *local,
				struct sk_buff_head *skbs);
1720 1721
void ieee80211_flush_queues(struct ieee80211_local *local,
			    struct ieee80211_sub_if_data *sdata);
K
Kalle Valo 已提交
1722

1723
void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
1724
			 u16 transaction, u16 auth_alg, u16 status,
J
Johannes Berg 已提交
1725
			 const u8 *extra, size_t extra_len, const u8 *bssid,
1726 1727
			 const u8 *da, const u8 *key, u8 key_len, u8 key_idx,
			 u32 tx_flags);
1728 1729 1730
void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
				    const u8 *bssid, u16 stype, u16 reason,
				    bool send_frame, u8 *frame_buf);
1731
int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
1732
			     size_t buffer_len, const u8 *ie, size_t ie_len,
1733
			     enum ieee80211_band band, u32 rate_mask,
1734
			     struct cfg80211_chan_def *chandef);
1735
struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
1736
					  u8 *dst, u32 ratemask,
1737
					  struct ieee80211_channel *chan,
1738
					  const u8 *ssid, size_t ssid_len,
1739 1740
					  const u8 *ie, size_t ie_len,
					  bool directed);
1741
void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
1742
			      const u8 *ssid, size_t ssid_len,
1743
			      const u8 *ie, size_t ie_len,
1744
			      u32 ratemask, bool directed, u32 tx_flags,
J
Johannes Berg 已提交
1745
			      struct ieee80211_channel *channel, bool scan);
1746

1747
u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata,
1748
			    struct ieee802_11_elems *elems,
1749
			    enum ieee80211_band band, u32 *basic_rates);
1750 1751 1752 1753
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);
1754
void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata);
1755
void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata);
1756

1757 1758 1759
size_t ieee80211_ie_split(const u8 *ies, size_t ielen,
			  const u8 *ids, int n_ids, size_t offset);
size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset);
B
Ben Greear 已提交
1760
u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
1761
			      u16 cap);
1762
u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
1763
			       const struct cfg80211_chan_def *chandef,
1764
			       u16 prot_mode);
1765 1766
u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
			       u32 cap);
1767 1768 1769
int ieee80211_parse_bitrates(struct cfg80211_chan_def *chandef,
			     const struct ieee80211_supported_band *sband,
			     const u8 *srates, int srates_len, u32 *rates);
1770
int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata,
1771 1772
			    struct sk_buff *skb, bool need_basic,
			    enum ieee80211_band band);
1773
int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata,
1774 1775
				struct sk_buff *skb, bool need_basic,
				enum ieee80211_band band);
1776

1777
/* channel management */
1778
void ieee80211_ht_oper_to_chandef(struct ieee80211_channel *control_chan,
J
Johannes Berg 已提交
1779
				  const struct ieee80211_ht_operation *ht_oper,
1780
				  struct cfg80211_chan_def *chandef);
1781
u32 ieee80211_chandef_downgrade(struct cfg80211_chan_def *c);
1782

1783 1784
int __must_check
ieee80211_vif_use_channel(struct ieee80211_sub_if_data *sdata,
1785
			  const struct cfg80211_chan_def *chandef,
1786
			  enum ieee80211_chanctx_mode mode);
1787 1788 1789
int __must_check
ieee80211_vif_reserve_chanctx(struct ieee80211_sub_if_data *sdata,
			      const struct cfg80211_chan_def *chandef,
1790 1791
			      enum ieee80211_chanctx_mode mode,
			      bool radar_required);
1792 1793 1794 1795 1796
int __must_check
ieee80211_vif_use_reserved_context(struct ieee80211_sub_if_data *sdata,
				   u32 *changed);
int ieee80211_vif_unreserve_chanctx(struct ieee80211_sub_if_data *sdata);

1797 1798 1799 1800
int __must_check
ieee80211_vif_change_bandwidth(struct ieee80211_sub_if_data *sdata,
			       const struct cfg80211_chan_def *chandef,
			       u32 *changed);
1801 1802 1803 1804
/* NOTE: only use ieee80211_vif_change_channel() for channel switch */
int __must_check
ieee80211_vif_change_channel(struct ieee80211_sub_if_data *sdata,
			     u32 *changed);
1805
void ieee80211_vif_release_channel(struct ieee80211_sub_if_data *sdata);
1806
void ieee80211_vif_vlan_copy_chanctx(struct ieee80211_sub_if_data *sdata);
1807 1808
void ieee80211_vif_copy_chanctx_to_vlans(struct ieee80211_sub_if_data *sdata,
					 bool clear);
1809 1810
int ieee80211_chanctx_refcount(struct ieee80211_local *local,
			       struct ieee80211_chanctx *ctx);
1811

1812 1813
void ieee80211_recalc_smps_chanctx(struct ieee80211_local *local,
				   struct ieee80211_chanctx *chanctx);
1814 1815
void ieee80211_recalc_chanctx_min_def(struct ieee80211_local *local,
				      struct ieee80211_chanctx *ctx);
1816 1817 1818 1819 1820

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);
1821 1822
int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
			      struct cfg80211_csa_settings *csa_settings);
1823

1824 1825 1826 1827 1828 1829 1830 1831
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);
1832 1833
void ieee80211_recalc_dtim(struct ieee80211_local *local,
			   struct ieee80211_sub_if_data *sdata);
1834 1835 1836 1837
int ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata,
				 const struct cfg80211_chan_def *chandef,
				 enum ieee80211_chanctx_mode chanmode,
				 u8 radar_detect);
1838
int ieee80211_max_num_channels(struct ieee80211_local *local);
1839

1840 1841 1842 1843 1844 1845 1846 1847 1848
/* TDLS */
int ieee80211_tdls_mgmt(struct wiphy *wiphy, struct net_device *dev,
			u8 *peer, u8 action_code, u8 dialog_token,
			u16 status_code, u32 peer_capability,
			const u8 *extra_ies, size_t extra_ies_len);
int ieee80211_tdls_oper(struct wiphy *wiphy, struct net_device *dev,
			u8 *peer, enum nl80211_tdls_operation oper);


1849
#ifdef CONFIG_MAC80211_NOINLINE
1850 1851 1852 1853 1854
#define debug_noinline noinline
#else
#define debug_noinline
#endif

1855
#endif /* IEEE80211_I_H */