ieee80211_i.h 58.0 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 756 757 758
	struct work_struct csa_finalize_work;
	int csa_counter_offset_beacon;
	int csa_counter_offset_presp;
	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

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

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

776 777 778
	u8 needed_rx_chains;
	enum ieee80211_smps_mode smps_mode;

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

782 783 784
	bool radar_required;
	struct delayed_work dfs_cac_timer_work;

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

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

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

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

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

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

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

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

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

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

J
Johannes Berg 已提交
850 851 852 853 854 855 856 857 858
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))
859
		band = chanctx_conf->def.chan->band;
J
Johannes Berg 已提交
860 861 862 863 864
	rcu_read_unlock();

	return band;
}

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

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

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

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

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

929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
/*
 * 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[];
};

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

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

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

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

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

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

1020 1021
	bool wiphy_ciphers_allocated;

1022 1023
	bool use_chanctx;

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

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

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

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

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

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

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

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

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

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

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

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

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

1084
	spinlock_t rx_path_lock;
1085

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

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

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

1108
	atomic_t agg_queue_stop[IEEE80211_MAX_QUEUES];
1109

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

	struct rate_control_ref *rate_ctrl;

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

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

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

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

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

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

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

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

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

1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
	/* 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 已提交
1174
	struct led_trigger *tx_led, *rx_led, *assoc_led, *radio_led;
1175
	struct tpt_led_trigger *tpt_led_trigger;
I
Ivo van Doorn 已提交
1176 1177
	char tx_led_name[32], rx_led_name[32],
	     assoc_led_name[32], radio_led_name[32];
1178 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
#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
				*/
1209

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

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

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

1232 1233
	enum ieee80211_smps_mode smps_mode;

1234 1235
	struct work_struct restart_work;

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

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

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

1254 1255
	struct ieee80211_sub_if_data __rcu *p2p_sdata;

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

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

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

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

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

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

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

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

	/* 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 已提交
1343 1344 1345

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

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


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

1361 1362 1363 1364 1365 1366 1367
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);
}
1368

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static inline int __ieee80211_resume(struct ieee80211_hw *hw)
{
1620 1621 1622 1623 1624 1625
	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));

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

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

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

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

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

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

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

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

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

1756 1757 1758
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 已提交
1759
u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
1760
			      u16 cap);
1761
u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
1762
			       const struct cfg80211_chan_def *chandef,
1763
			       u16 prot_mode);
1764 1765
u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
			       u32 cap);
1766 1767 1768
int ieee80211_parse_bitrates(struct cfg80211_chan_def *chandef,
			     const struct ieee80211_supported_band *sband,
			     const u8 *srates, int srates_len, u32 *rates);
1769
int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata,
1770 1771
			    struct sk_buff *skb, bool need_basic,
			    enum ieee80211_band band);
1772
int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata,
1773 1774
				struct sk_buff *skb, bool need_basic,
				enum ieee80211_band band);
1775

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

1782 1783
int __must_check
ieee80211_vif_use_channel(struct ieee80211_sub_if_data *sdata,
1784
			  const struct cfg80211_chan_def *chandef,
1785
			  enum ieee80211_chanctx_mode mode);
1786 1787 1788
int __must_check
ieee80211_vif_reserve_chanctx(struct ieee80211_sub_if_data *sdata,
			      const struct cfg80211_chan_def *chandef,
1789 1790
			      enum ieee80211_chanctx_mode mode,
			      bool radar_required);
1791 1792 1793 1794 1795
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);

1796 1797 1798 1799
int __must_check
ieee80211_vif_change_bandwidth(struct ieee80211_sub_if_data *sdata,
			       const struct cfg80211_chan_def *chandef,
			       u32 *changed);
1800 1801 1802 1803
/* 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);
1804
void ieee80211_vif_release_channel(struct ieee80211_sub_if_data *sdata);
1805
void ieee80211_vif_vlan_copy_chanctx(struct ieee80211_sub_if_data *sdata);
1806 1807
void ieee80211_vif_copy_chanctx_to_vlans(struct ieee80211_sub_if_data *sdata,
					 bool clear);
1808 1809
int ieee80211_chanctx_refcount(struct ieee80211_local *local,
			       struct ieee80211_chanctx *ctx);
1810

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

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

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

1839 1840 1841 1842 1843 1844 1845 1846 1847
/* 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);


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

1854
#endif /* IEEE80211_I_H */