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

#ifndef IEEE80211_I_H
#define IEEE80211_I_H

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

37
struct ieee80211_local;
38 39 40 41 42 43 44 45 46 47 48 49

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

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

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

61
/*
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
 * Some APs experience problems when working with U-APSD. Decreasing the
 * probability of that happening by using legacy mode for all ACs but VO isn't
 * enough.
 *
 * Cisco 4410N originally forced us to enable VO by default only because it
 * treated non-VO ACs as legacy.
 *
 * However some APs (notably Netgear R7000) silently reclassify packets to
 * different ACs. Since u-APSD ACs require trigger frames for frame retrieval
 * clients would never see some frames (e.g. ARP responses) or would fetch them
 * accidentally after a long time.
 *
 * It makes little sense to enable u-APSD queues by default because it needs
 * userspace applications to be aware of it to actually take advantage of the
 * possible additional powersavings. Implicitly depending on driver autotrigger
 * frame support doesn't make much sense.
78
 */
79
#define IEEE80211_DEFAULT_UAPSD_QUEUES 0
K
Kalle Valo 已提交
80 81 82 83

#define IEEE80211_DEFAULT_MAX_SP_LEN		\
	IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL

84 85
#define IEEE80211_DEAUTH_FRAME_LEN	(24 /* hdr */ + 2 /* reason */)

86 87 88 89 90 91 92 93 94 95 96 97
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 */
};


98
struct ieee80211_bss {
99
	u32 device_ts_beacon, device_ts_presp;
100

101
	bool wmm_used;
K
Kalle Valo 已提交
102
	bool uapsd_supported;
103

104 105 106
#define IEEE80211_MAX_SUPP_RATES 32
	u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
	size_t supp_rates_len;
107
	struct ieee80211_rate *beacon_rate;
108

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

	/* Keep track of the corruption of the last beacon/probe response. */
	u8 corrupt_data;

	/* Keep track of what bits of information we have valid info for. */
	u8 valid_data;
};

/**
 * enum ieee80211_corrupt_data_flags - BSS data corruption flags
 * @IEEE80211_BSS_CORRUPT_BEACON: last beacon frame received was corrupted
 * @IEEE80211_BSS_CORRUPT_PROBE_RESP: last probe response received was corrupted
 *
 * These are bss flags that are attached to a bss in the
 * @corrupt_data field of &struct ieee80211_bss.
 */
enum ieee80211_bss_corrupt_data_flags {
	IEEE80211_BSS_CORRUPT_BEACON		= BIT(0),
	IEEE80211_BSS_CORRUPT_PROBE_RESP	= BIT(1)
};

/**
 * enum ieee80211_valid_data_flags - BSS valid data flags
 * @IEEE80211_BSS_VALID_WMM: WMM/UAPSD data was gathered from non-corrupt IE
 * @IEEE80211_BSS_VALID_RATES: Supported rates were gathered from non-corrupt IE
 * @IEEE80211_BSS_VALID_ERP: ERP flag was gathered from non-corrupt IE
 *
 * These are bss flags that are attached to a bss in the
 * @valid_data field of &struct ieee80211_bss.  They show which parts
S
Stephen Hemminger 已提交
146
 * of the data structure were received as a result of an un-corrupted
P
Paul Stewart 已提交
147 148 149 150 151 152
 * 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)
153 154
};

155 156 157 158 159
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)

160 161 162 163 164
#define IEEE80211_TX_UNICAST		BIT(1)
#define IEEE80211_TX_PS_BUFFERED	BIT(2)

struct ieee80211_tx_data {
	struct sk_buff *skb;
165
	struct sk_buff_head skbs;
166 167 168 169
	struct ieee80211_local *local;
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;
	struct ieee80211_key *key;
170
	struct ieee80211_tx_rate rate;
171

172
	unsigned int flags;
173 174 175
};


176
typedef unsigned __bitwise__ ieee80211_rx_result;
J
Johannes Berg 已提交
177 178 179 180
#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)
181

182 183 184 185 186 187 188
/**
 * 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
189
 * @IEEE80211_RX_DEFERRED_RELEASE: frame was subjected to receive reordering
190 191 192 193 194 195 196 197 198
 *
 * 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),
199
	IEEE80211_RX_DEFERRED_RELEASE		= BIT(5),
200 201 202 203 204 205
};

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

struct ieee80211_rx_data {
218 219 220 221 222
	struct sk_buff *skb;
	struct ieee80211_local *local;
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;
	struct ieee80211_key *key;
223 224

	unsigned int flags;
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240

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

241 242
	u32 tkip_iv32;
	u16 tkip_iv16;
243 244
};

245 246 247 248 249 250 251 252 253 254
struct ieee80211_csa_settings {
	const u16 *counter_offsets_beacon;
	const u16 *counter_offsets_presp;

	int n_counter_offsets_beacon;
	int n_counter_offsets_presp;

	u8 count;
};

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

264 265 266
struct probe_resp {
	struct rcu_head rcu_head;
	int len;
267
	u16 csa_counter_offsets[IEEE80211_MAX_CSA_COUNTERS_NUM];
268 269 270
	u8 data[0];
};

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

283 284 285 286
struct ieee80211_if_ap {
	struct beacon_data __rcu *beacon;
	struct probe_resp __rcu *probe_resp;

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

	struct ps_data ps;
	atomic_t num_mcast_sta; /* number of stations receiving multicast */
293 294 295 296
	enum ieee80211_smps_mode req_smps, /* requested smps mode */
			 driver_smps_mode; /* smps mode request */

	struct work_struct request_smps_work;
297 298
};

299 300
struct ieee80211_if_wds {
	struct sta_info *sta;
301
	u8 remote_addr[ETH_ALEN];
302 303 304
};

struct ieee80211_if_vlan {
305
	struct list_head list; /* write-protected with RTNL and local->mtx */
306 307

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

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

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

328 329 330 331 332
#if HZ/100 == 0
#define IEEE80211_ROC_MIN_LEFT	1
#else
#define IEEE80211_ROC_MIN_LEFT	(HZ/100)
#endif
J
Johannes Berg 已提交
333

334
struct ieee80211_roc_work {
335
	struct list_head list;
336
	struct list_head dependents;
337

338
	struct delayed_work work;
J
Johannes Berg 已提交
339 340 341

	struct ieee80211_sub_if_data *sdata;

342
	struct ieee80211_channel *chan;
J
Johannes Berg 已提交
343

344
	bool started, abort, hw_begun, notified;
345
	bool to_be_freed;
346
	bool on_channel;
347

348
	unsigned long hw_start_time;
349

350 351
	u32 duration, req_duration;
	struct sk_buff *frame;
352
	u64 cookie, mgmt_tx_cookie;
353
	enum ieee80211_roc_type type;
354 355
};

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

J
Johannes Berg 已提交
373 374 375 376 377 378 379 380 381
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;
382
	bool timeout_started;
J
Johannes Berg 已提交
383

384 385 386
	u16 sae_trans, sae_status;
	size_t data_len;
	u8 data[];
J
Johannes Berg 已提交
387 388 389 390 391 392 393 394 395 396 397 398 399 400
};

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;
401
	bool wmm, uapsd;
402
	bool need_beacon;
J
Johannes Berg 已提交
403
	bool synced;
404
	bool timeout_started;
J
Johannes Berg 已提交
405

406 407
	u8 ap_ht_param;

408 409
	struct ieee80211_vht_cap ap_vht_cap;

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

414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
struct ieee80211_sta_tx_tspec {
	/* timestamp of the first packet in the time slice */
	unsigned long time_slice_start;

	u32 admitted_time; /* in usecs, unlike over the air */
	u8 tsid;
	s8 up; /* signed to be able to invalidate with -1 during teardown */

	/* consumed TX time in microseconds in the time slice */
	u32 consumed_tx_time;
	enum {
		TX_TSPEC_ACTION_NONE = 0,
		TX_TSPEC_ACTION_DOWNGRADE,
		TX_TSPEC_ACTION_STOP_DOWNGRADE,
	} action;
	bool downgraded;
};

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

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

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

452
	u8 bssid[ETH_ALEN];
453

454 455
	u16 aid;

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

	struct work_struct request_smps_work;
464

465
	unsigned int flags;
466

467
	bool csa_waiting_bcn;
468
	bool csa_ignored_same_chan;
469

470
	bool beacon_crc_valid;
471 472
	u32 beacon_crc;

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

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

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

497
	int wmm_last_param_set;
498 499

	u8 use_4addr;
500

J
Janusz Dziedzic 已提交
501
	s16 p2p_noa_index;
502

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

514 515 516 517 518 519 520
	/*
	 * 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;

521 522 523 524 525 526
	/*
	 * 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;
527 528 529 530 531 532 533 534

	/*
	 * 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 已提交
535 536 537

	struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
	struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */
538 539
	struct ieee80211_vht_cap vht_capa; /* configured VHT overrides */
	struct ieee80211_vht_cap vht_capa_mask; /* Valid parts of vht_capa */
540

541
	/* TDLS support */
542 543
	u8 tdls_peer[ETH_ALEN] __aligned(2);
	struct delayed_work tdls_peer_del_work;
544 545 546
	struct sk_buff *orig_teardown_skb; /* The original teardown skb */
	struct sk_buff *teardown_skb; /* A copy to send through the AP */
	spinlock_t teardown_lock; /* To lock changing teardown_skb */
547
	bool tdls_chan_switch_prohibited;
548 549 550 551 552 553 554 555 556 557

	/* WMM-AC TSPEC support */
	struct ieee80211_sta_tx_tspec tx_tspec[IEEE80211_NUM_ACS];
	/* Use a separate work struct so that we can do something here
	 * while the sdata->work is flushing the queues, for example.
	 * otherwise, in scenarios where we hardly get any traffic out
	 * on the BE queue, but there's a lot of VO traffic, we might
	 * get stuck in a downgraded situation and flush takes forever.
	 */
	struct delayed_work tx_tspec_wk;
558 559
};

560 561
struct ieee80211_if_ibss {
	struct timer_list timer;
562
	struct work_struct csa_connection_drop_work;
563

564
	unsigned long last_scan_completed;
565

566 567
	u32 basic_rates;

568 569
	bool fixed_bssid;
	bool fixed_channel;
J
Johannes Berg 已提交
570
	bool privacy;
571

572
	bool control_port;
573
	bool userspace_handles_dfs;
574

575
	u8 bssid[ETH_ALEN] __aligned(2);
576 577 578
	u8 ssid[IEEE80211_MAX_SSID_LEN];
	u8 ssid_len, ie_len;
	u8 *ie;
579
	struct cfg80211_chan_def chandef;
580 581

	unsigned long ibss_join_req;
582
	/* probe response/beacon for IBSS */
583
	struct beacon_data __rcu *presp;
584

585 586 587
	struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
	struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */

588 589 590
	spinlock_t incomplete_lock;
	struct list_head incomplete_stations;

591 592 593 594 595 596
	enum {
		IEEE80211_IBSS_MLME_SEARCH,
		IEEE80211_IBSS_MLME_JOINED,
	} state;
};

597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
/**
 * struct ieee80211_if_ocb - OCB mode state
 *
 * @housekeeping_timer: timer for periodic invocation of a housekeeping task
 * @wrkq_flags: OCB deferred task action
 * @incomplete_lock: delayed STA insertion lock
 * @incomplete_stations: list of STAs waiting for delayed insertion
 * @joined: indication if the interface is connected to an OCB network
 */
struct ieee80211_if_ocb {
	struct timer_list housekeeping_timer;
	unsigned long wrkq_flags;

	spinlock_t incomplete_lock;
	struct list_head incomplete_stations;

	bool joined;
};

616 617 618 619 620 621 622 623 624 625 626 627 628 629
/**
 * 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);
630 631 632 633

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

637 638 639 640 641
struct mesh_csa_settings {
	struct rcu_head rcu_head;
	struct cfg80211_csa_settings settings;
};

642 643 644
struct ieee80211_if_mesh {
	struct timer_list housekeeping_timer;
	struct timer_list mesh_path_timer;
645
	struct timer_list mesh_path_root_timer;
646

647
	unsigned long wrkq_flags;
648
	unsigned long mbss_changed;
649 650 651 652

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

	/* offset from skb->data while building IE */
	int meshconf_offset;
714
};
J
Johannes Berg 已提交
715 716

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

724 725 726 727 728 729 730 731 732
/**
 * 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.
733
 * @IEEE80211_SDATA_DISCONNECT_RESUME: Disconnect after resume.
734
 * @IEEE80211_SDATA_IN_DRIVER: indicates interface was added to driver
735 736 737 738
 */
enum ieee80211_sub_if_data_flags {
	IEEE80211_SDATA_ALLMULTI		= BIT(0),
	IEEE80211_SDATA_PROMISC			= BIT(1),
739 740
	IEEE80211_SDATA_OPERATING_GMODE		= BIT(2),
	IEEE80211_SDATA_DONT_BRIDGE_PACKETS	= BIT(3),
741
	IEEE80211_SDATA_DISCONNECT_RESUME	= BIT(4),
742
	IEEE80211_SDATA_IN_DRIVER		= BIT(5),
743 744
};

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

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

775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
/**
 * enum ieee80211_chanctx_replace_state - channel context replacement state
 *
 * This is used for channel context in-place reservations that require channel
 * context switch/swap.
 *
 * @IEEE80211_CHANCTX_REPLACE_NONE: no replacement is taking place
 * @IEEE80211_CHANCTX_WILL_BE_REPLACED: this channel context will be replaced
 *	by a (not yet registered) channel context pointed by %replace_ctx.
 * @IEEE80211_CHANCTX_REPLACES_OTHER: this (not yet registered) channel context
 *	replaces an existing channel context pointed to by %replace_ctx.
 */
enum ieee80211_chanctx_replace_state {
	IEEE80211_CHANCTX_REPLACE_NONE,
	IEEE80211_CHANCTX_WILL_BE_REPLACED,
	IEEE80211_CHANCTX_REPLACES_OTHER,
};

793 794 795 796
struct ieee80211_chanctx {
	struct list_head list;
	struct rcu_head rcu_head;

797
	struct list_head assigned_vifs;
798
	struct list_head reserved_vifs;
799

800 801 802
	enum ieee80211_chanctx_replace_state replace_state;
	struct ieee80211_chanctx *replace_ctx;

803
	enum ieee80211_chanctx_mode mode;
804
	bool driver_present;
805 806 807 808

	struct ieee80211_chanctx_conf conf;
};

809 810 811 812 813
struct mac80211_qos_map {
	struct cfg80211_qos_map qos_map;
	struct rcu_head rcu_head;
};

814 815 816 817 818
struct ieee80211_sub_if_data {
	struct list_head list;

	struct wireless_dev wdev;

J
Johannes Berg 已提交
819 820 821
	/* keys */
	struct list_head key_list;

822 823
	/* count for keys needing tailroom space allocation */
	int crypto_tx_tailroom_needed_cnt;
824 825
	int crypto_tx_tailroom_pending_dec;
	struct delayed_work dec_tailroom_needed_wk;
826

827 828 829
	struct net_device *dev;
	struct ieee80211_local *local;

830
	unsigned int flags;
831

832 833
	unsigned long state;

834 835
	char name[IFNAMSIZ];

836 837 838 839
	/* Fragment table for host-based reassembly */
	struct ieee80211_fragment_entry	fragments[IEEE80211_FRAGMENT_MAX];
	unsigned int fragment_next;

840 841 842
	/* TID bitmap for NoAck policy */
	u16 noack_map;

Y
Yoni Divinsky 已提交
843 844 845
	/* bit field of ACM bits (BIT(802.1D tag)) */
	u8 wmm_acm;

J
Johannes Berg 已提交
846 847 848 849
	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;
850

J
Johannes Berg 已提交
851
	u16 sequence_number;
852 853
	__be16 control_port_protocol;
	bool control_port_no_encrypt;
854
	int encrypt_headroom;
J
Johannes Berg 已提交
855

856
	struct ieee80211_tx_queue_params tx_conf[IEEE80211_NUM_ACS];
857
	struct mac80211_qos_map __rcu *qos_map;
858

859
	struct work_struct csa_finalize_work;
860
	bool csa_block_tx; /* write-protected by sdata_lock and local->mtx */
861
	struct cfg80211_chan_def csa_chandef;
862

863
	struct list_head assigned_chanctx_list; /* protected by chanctx_mtx */
864
	struct list_head reserved_chanctx_list; /* protected by chanctx_mtx */
865

866 867 868
	/* context reservation -- protected with chanctx_mtx */
	struct ieee80211_chanctx *reserved_chanctx;
	struct cfg80211_chan_def reserved_chandef;
869
	bool reserved_radar_required;
870
	bool reserved_ready;
871

872 873 874
	/* used to reconfigure hardware SM PS */
	struct work_struct recalc_smps;

J
Johannes Berg 已提交
875
	struct work_struct work;
J
Johannes Berg 已提交
876 877
	struct sk_buff_head skb_queue;

878 879 880
	u8 needed_rx_chains;
	enum ieee80211_smps_mode smps_mode;

881 882 883
	int user_power_level; /* in dBm */
	int ap_power_level; /* in dBm */

884 885 886
	bool radar_required;
	struct delayed_work dfs_cac_timer_work;

887
	/*
888 889 890
	 * AP this belongs to: self in AP mode and
	 * corresponding AP in VLAN mode, NULL for
	 * all others (might be needed later in IBSS)
891
	 */
892 893
	struct ieee80211_if_ap *bss;

894 895
	/* bitmap of allowed (non-MCS) rate indexes for rate control */
	u32 rc_rateidx_mask[IEEE80211_NUM_BANDS];
896 897

	bool rc_has_mcs_mask[IEEE80211_NUM_BANDS];
898
	u8  rc_rateidx_mcs_mask[IEEE80211_NUM_BANDS][IEEE80211_HT_MCS_MASK_LEN];
899 900 901 902 903

	union {
		struct ieee80211_if_ap ap;
		struct ieee80211_if_wds wds;
		struct ieee80211_if_vlan vlan;
904 905
		struct ieee80211_if_managed mgd;
		struct ieee80211_if_ibss ibss;
906
		struct ieee80211_if_mesh mesh;
907
		struct ieee80211_if_ocb ocb;
908
		u32 mntr_flags;
909
	} u;
J
Jiri Benc 已提交
910 911

#ifdef CONFIG_MAC80211_DEBUGFS
912
	struct {
913
		struct dentry *subdir_stations;
914 915
		struct dentry *default_unicast_key;
		struct dentry *default_multicast_key;
916
		struct dentry *default_mgmt_key;
917
	} debugfs;
J
Jiri Benc 已提交
918
#endif
919

920 921
	/* must be last, dynamically sized area in this! */
	struct ieee80211_vif vif;
922 923
};

924 925 926 927 928 929
static inline
struct ieee80211_sub_if_data *vif_to_sdata(struct ieee80211_vif *p)
{
	return container_of(p, struct ieee80211_sub_if_data, vif);
}

930 931 932 933 934 935 936 937 938 939 940 941 942 943
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);
}

944 945 946
#define sdata_dereference(p, sdata) \
	rcu_dereference_protected(p, lockdep_is_held(&sdata->wdev.mtx))

947 948 949 950 951 952
static inline void
sdata_assert_lock(struct ieee80211_sub_if_data *sdata)
{
	lockdep_assert_held(&sdata->wdev.mtx);
}

J
Johannes Berg 已提交
953 954 955 956 957 958 959 960 961
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))
962
		band = chanctx_conf->def.chan->band;
J
Johannes Berg 已提交
963 964 965 966 967
	rcu_read_unlock();

	return band;
}

968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995
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;
}

996 997 998 999 1000
struct ieee80211_rx_agg {
	u8 addr[ETH_ALEN];
	u16 tid;
};

1001 1002 1003 1004
enum sdata_queue_type {
	IEEE80211_SDATA_QUEUE_TYPE_FRAME	= 0,
	IEEE80211_SDATA_QUEUE_AGG_START		= 1,
	IEEE80211_SDATA_QUEUE_AGG_STOP		= 2,
1005 1006
	IEEE80211_SDATA_QUEUE_RX_AGG_START	= 3,
	IEEE80211_SDATA_QUEUE_RX_AGG_STOP	= 4,
1007
	IEEE80211_SDATA_QUEUE_TDLS_CHSW		= 5,
1008 1009
};

1010 1011 1012 1013 1014
enum {
	IEEE80211_RX_MSG	= 1,
	IEEE80211_TX_STATUS_MSG	= 2,
};

K
Kalle Valo 已提交
1015 1016
enum queue_stop_reason {
	IEEE80211_QUEUE_STOP_REASON_DRIVER,
1017
	IEEE80211_QUEUE_STOP_REASON_PS,
1018 1019
	IEEE80211_QUEUE_STOP_REASON_CSA,
	IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
1020
	IEEE80211_QUEUE_STOP_REASON_SUSPEND,
1021
	IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
1022
	IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL,
1023
	IEEE80211_QUEUE_STOP_REASON_FLUSH,
1024
	IEEE80211_QUEUE_STOP_REASON_TDLS_TEARDOWN,
1025
	IEEE80211_QUEUE_STOP_REASON_RESERVE_TID,
1026 1027

	IEEE80211_QUEUE_STOP_REASONS,
K
Kalle Valo 已提交
1028 1029
};

1030
#ifdef CONFIG_MAC80211_LEDS
1031 1032 1033 1034 1035 1036 1037 1038
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;
1039 1040
	unsigned int active, want;
	bool running;
1041
};
1042
#endif
1043

1044 1045 1046 1047 1048 1049 1050
/**
 * 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
1051 1052
 * @SCAN_ONCHANNEL_SCANNING:  Do a software scan on only the current operating
 *	channel. This should not interrupt normal traffic.
1053 1054 1055 1056
 * @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.
1057 1058
 * @SCAN_HW_CANCELLED: Set for our scan work function when the scan is being
 *	cancelled.
1059
 */
1060 1061
enum {
	SCAN_SW_SCANNING,
1062
	SCAN_HW_SCANNING,
1063
	SCAN_ONCHANNEL_SCANNING,
1064 1065
	SCAN_COMPLETED,
	SCAN_ABORTED,
1066
	SCAN_HW_CANCELLED,
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
};

/**
 * 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
1077 1078 1079
 * @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
1080
 * @SCAN_ABORT: Abort the scan and go back to operating channel
1081 1082 1083 1084 1085
 */
enum mac80211_scan_state {
	SCAN_DECISION,
	SCAN_SET_CHANNEL,
	SCAN_SEND_PROBE,
1086 1087
	SCAN_SUSPEND,
	SCAN_RESUME,
1088
	SCAN_ABORT,
1089 1090
};

1091 1092 1093 1094 1095 1096 1097 1098
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;

1099 1100 1101 1102 1103 1104
	/*
	 * private workqueue to mac80211. mac80211 makes this accessible
	 * via ieee80211_queue_work()
	 */
	struct workqueue_struct *workqueue;

1105
	unsigned long queue_stop_reasons[IEEE80211_MAX_QUEUES];
1106
	int q_stop_reasons[IEEE80211_MAX_QUEUES][IEEE80211_QUEUE_STOP_REASONS];
1107
	/* also used to protect ampdu_ac_queue and amdpu_ac_stop_refcnt */
K
Kalle Valo 已提交
1108
	spinlock_t queue_stop_reason_lock;
1109

1110
	int open_count;
1111
	int monitors, cooked_mntrs;
1112
	/* number of interfaces with corresponding FIF_ flags */
1113 1114 1115
	int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss, fif_pspoll,
	    fif_probe_req;
	int probe_req_reg;
1116
	unsigned int filter_flags; /* FIF_* */
J
Johannes Berg 已提交
1117

1118 1119
	bool wiphy_ciphers_allocated;

1120 1121
	bool use_chanctx;

J
Johannes Berg 已提交
1122 1123 1124
	/* protects the aggregated multicast list and filter calls */
	spinlock_t filter_lock;

1125 1126 1127
	/* used for uploading changed mc list */
	struct work_struct reconfig_filter;

J
Johannes Berg 已提交
1128
	/* aggregated multicast list */
1129
	struct netdev_hw_addr_list mc_list;
J
Johannes Berg 已提交
1130

1131
	bool tim_in_locked_section; /* see ieee80211_beacon_get() */
1132 1133 1134 1135 1136 1137 1138 1139 1140

	/*
	 * 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 已提交
1141 1142 1143 1144 1145 1146 1147 1148
	/*
	 * 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;

1149 1150 1151 1152 1153 1154
	/*
	 * quiescing is true during the suspend process _only_ to
	 * ease timer cancelling etc.
	 */
	bool quiescing;

1155 1156 1157
	/* device is started */
	bool started;

1158 1159 1160
	/* device is during a HW reconfig */
	bool in_reconfig;

1161 1162 1163
	/* wowlan is enabled -- don't reconfig on resume */
	bool wowlan;

1164 1165
	struct work_struct radar_detected_work;

1166 1167 1168
	/* number of RX chains the hardware has */
	u8 rx_chains;

1169
	int tx_headroom; /* required headroom for hardware/radiotap */
1170 1171 1172 1173 1174 1175 1176 1177 1178 1179

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

1180
	spinlock_t rx_path_lock;
1181

1182 1183
	/* Station data */
	/*
1184 1185
	 * The mutex only protects the list, hash table and
	 * counter, reads are done with RCU.
1186
	 */
1187
	struct mutex sta_mtx;
1188
	spinlock_t tim_lock;
1189
	unsigned long num_sta;
1190
	struct list_head sta_list;
1191
	struct rhashtable sta_hash;
1192
	struct timer_list sta_cleanup;
1193
	int sta_generation;
1194

1195
	struct sk_buff_head pending[IEEE80211_MAX_QUEUES];
1196 1197
	struct tasklet_struct tx_pending_tasklet;

1198
	atomic_t agg_queue_stop[IEEE80211_MAX_QUEUES];
1199

1200 1201
	/* number of interfaces with corresponding IFF_ flags */
	atomic_t iff_allmultis, iff_promiscs;
1202 1203 1204

	struct rate_control_ref *rate_ctrl;

1205 1206
	struct crypto_cipher *wep_tx_tfm;
	struct crypto_cipher *wep_rx_tfm;
1207 1208
	u32 wep_iv;

1209
	/* see iface.c */
1210
	struct list_head interfaces;
1211
	struct mutex iflist_mtx;
1212

J
Johannes Berg 已提交
1213
	/*
J
Johannes Berg 已提交
1214
	 * Key mutex, protects sdata's key_list and sta_info's
J
Johannes Berg 已提交
1215 1216
	 * key pointers (write access, they're RCU.)
	 */
J
Johannes Berg 已提交
1217
	struct mutex key_mtx;
J
Johannes Berg 已提交
1218

1219 1220
	/* mutex for scan and work locking */
	struct mutex mtx;
J
Johannes Berg 已提交
1221

1222
	/* Scanning and BSS list */
1223
	unsigned long scanning;
1224
	struct cfg80211_ssid scan_ssid;
1225
	struct cfg80211_scan_request *int_scan_req;
1226
	struct cfg80211_scan_request __rcu *scan_req;
1227
	struct ieee80211_scan_request *hw_scan_req;
1228
	struct cfg80211_chan_def scan_chandef;
1229
	enum ieee80211_band hw_scan_band;
1230
	int scan_channel_idx;
1231
	int scan_ies_len;
1232
	int hw_scan_ies_bufsize;
1233

1234
	struct work_struct sched_scan_stopped_work;
1235
	struct ieee80211_sub_if_data __rcu *sched_scan_sdata;
1236
	struct cfg80211_sched_scan_request __rcu *sched_scan_req;
1237
	u8 scan_addr[ETH_ALEN];
1238

1239
	unsigned long leave_oper_channel_time;
1240
	enum mac80211_scan_state next_scan_state;
1241
	struct delayed_work scan_work;
1242
	struct ieee80211_sub_if_data __rcu *scan_sdata;
J
Johannes Berg 已提交
1243
	/* For backward compatibility only -- do not use */
1244
	struct cfg80211_chan_def _oper_chandef;
1245

1246 1247 1248
	/* Temporary remain-on-channel for off-channel operations */
	struct ieee80211_channel *tmp_channel;

1249 1250 1251 1252
	/* channel contexts */
	struct list_head chanctx_list;
	struct mutex chanctx_mtx;

1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265
	/* 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 已提交
1266
	struct led_trigger *tx_led, *rx_led, *assoc_led, *radio_led;
1267
	struct tpt_led_trigger *tpt_led_trigger;
I
Ivo van Doorn 已提交
1268 1269
	char tx_led_name[32], rx_led_name[32],
	     assoc_led_name[32], radio_led_name[32];
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299
#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_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
				*/
1300

1301
	bool pspolling;
1302
	bool offchannel_ps_enabled;
1303 1304 1305 1306 1307
	/*
	 * 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;
1308 1309 1310
	struct work_struct dynamic_ps_enable_work;
	struct work_struct dynamic_ps_disable_work;
	struct timer_list dynamic_ps_timer;
1311
	struct notifier_block network_latency_notifier;
1312
	struct notifier_block ifa_notifier;
1313
	struct notifier_block ifa6_notifier;
1314

1315 1316 1317 1318 1319 1320
	/*
	 * The dynamic ps timeout configured from user space via WEXT -
	 * this will override whatever chosen by mac80211 internally.
	 */
	int dynamic_ps_forced_timeout;

1321
	int user_power_level; /* in dBm, for all interfaces */
1322

1323 1324
	enum ieee80211_smps_mode smps_mode;

1325 1326
	struct work_struct restart_work;

J
Jiri Benc 已提交
1327 1328
#ifdef CONFIG_MAC80211_DEBUGFS
	struct local_debugfsdentries {
1329
		struct dentry *rcdir;
J
Jiri Benc 已提交
1330 1331 1332
		struct dentry *keys;
	} debugfs;
#endif
1333

1334 1335 1336 1337
	/*
	 * Remain-on-channel support
	 */
	struct list_head roc_list;
1338
	struct work_struct hw_roc_start, hw_roc_done;
1339
	unsigned long hw_roc_start_time;
1340
	u64 roc_cookie_counter;
1341

J
Johannes Berg 已提交
1342 1343 1344
	struct idr ack_status_frames;
	spinlock_t ack_status_lock;

1345 1346
	struct ieee80211_sub_if_data __rcu *p2p_sdata;

J
Johannes Berg 已提交
1347 1348
	struct napi_struct *napi;

1349 1350
	/* virtual monitor interface */
	struct ieee80211_sub_if_data __rcu *monitor_sdata;
1351
	struct cfg80211_chan_def monitor_chandef;
1352 1353 1354

	/* extended capabilities provided by mac80211 */
	u8 ext_capa[8];
1355 1356
};

1357 1358 1359 1360 1361 1362
static inline struct ieee80211_sub_if_data *
IEEE80211_DEV_TO_SUB_IF(struct net_device *dev)
{
	return netdev_priv(dev);
}

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

1369
/* this struct represents 802.11n's RA/TID combination */
1370 1371 1372 1373 1374
struct ieee80211_ra_tid {
	u8 ra[ETH_ALEN];
	u16 tid;
};

1375 1376 1377 1378 1379 1380
/* 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;
1381
	u16 pre_value;
1382 1383
};

1384 1385
/* Parsed Information Elements */
struct ieee802_11_elems {
J
Johannes Berg 已提交
1386
	const u8 *ie_start;
1387 1388 1389
	size_t total_len;

	/* pointers to IEs */
1390 1391
	const struct ieee80211_tdls_lnkie *lnk_id;
	const struct ieee80211_ch_switch_timing *ch_sw_timing;
1392
	const u8 *ext_capab;
J
Johannes Berg 已提交
1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
	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;
1416
	const struct ieee80211_ext_chansw_ie *ext_chansw_ie;
1417
	const struct ieee80211_wide_bw_chansw_ie *wide_bw_chansw_ie;
J
Johannes Berg 已提交
1418 1419
	const u8 *country_elem;
	const u8 *pwr_constr_elem;
1420
	const u8 *cisco_dtpc_elem;
1421
	const struct ieee80211_timeout_interval_ie *timeout_int;
J
Johannes Berg 已提交
1422
	const u8 *opmode_notif;
1423
	const struct ieee80211_sec_chan_offs_ie *sec_chan_offs;
1424
	const struct ieee80211_mesh_chansw_params_ie *mesh_chansw_params_ie;
1425 1426

	/* length of them, respectively */
1427
	u8 ext_capab_len;
1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441
	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 已提交
1442 1443 1444

	/* whether a parse error occurred while retrieving these elements */
	bool parse_error;
1445 1446
};

1447 1448 1449 1450 1451 1452 1453
static inline struct ieee80211_local *hw_to_local(
	struct ieee80211_hw *hw)
{
	return container_of(hw, struct ieee80211_local, hw);
}


1454 1455
static inline int ieee80211_bssid_match(const u8 *raddr, const u8 *addr)
{
1456
	return ether_addr_equal(raddr, addr) ||
1457 1458 1459
	       is_broadcast_ether_addr(raddr);
}

1460 1461 1462 1463 1464 1465 1466
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);
}
1467

1468 1469 1470 1471
u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
				     struct ieee80211_rx_status *status,
				     unsigned int mpdu_len,
				     unsigned int mpdu_offset);
1472
int ieee80211_hw_config(struct ieee80211_local *local, u32 changed);
1473
void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx);
J
Johannes Berg 已提交
1474 1475
void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
				      u32 changed);
1476
void ieee80211_configure_filter(struct ieee80211_local *local);
1477
u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata);
1478

1479
/* STA code */
J
Johannes Berg 已提交
1480
void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata);
1481 1482 1483 1484 1485
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,
1486
			 struct cfg80211_deauth_request *req);
1487
int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
1488
			   struct cfg80211_disassoc_request *req);
1489 1490
void ieee80211_send_pspoll(struct ieee80211_local *local,
			   struct ieee80211_sub_if_data *sdata);
1491
void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency);
E
Eliad Peller 已提交
1492
void ieee80211_recalc_ps_vif(struct ieee80211_sub_if_data *sdata);
1493 1494
int ieee80211_max_network_latency(struct notifier_block *nb,
				  unsigned long data, void *dummy);
1495
int ieee80211_set_arp_filter(struct ieee80211_sub_if_data *sdata);
1496 1497 1498
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);
1499
void ieee80211_sta_reset_beacon_monitor(struct ieee80211_sub_if_data *sdata);
1500
void ieee80211_sta_reset_conn_monitor(struct ieee80211_sub_if_data *sdata);
1501
void ieee80211_mgd_stop(struct ieee80211_sub_if_data *sdata);
1502 1503
void ieee80211_mgd_conn_tx_status(struct ieee80211_sub_if_data *sdata,
				  __le16 fc, bool acked);
1504
void ieee80211_mgd_quiesce(struct ieee80211_sub_if_data *sdata);
1505
void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata);
1506
void ieee80211_sta_handle_tspec_ac_params(struct ieee80211_sub_if_data *sdata);
J
Johannes Berg 已提交
1507

1508 1509 1510
/* IBSS code */
void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local);
void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata);
1511 1512
void ieee80211_ibss_rx_no_sta(struct ieee80211_sub_if_data *sdata,
			      const u8 *bssid, const u8 *addr, u32 supp_rates);
1513 1514 1515
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);
1516 1517 1518
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);
1519 1520 1521 1522
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);
1523

1524 1525 1526 1527 1528 1529 1530 1531 1532
/* OCB code */
void ieee80211_ocb_work(struct ieee80211_sub_if_data *sdata);
void ieee80211_ocb_rx_no_sta(struct ieee80211_sub_if_data *sdata,
			     const u8 *bssid, const u8 *addr, u32 supp_rates);
void ieee80211_ocb_setup_sdata(struct ieee80211_sub_if_data *sdata);
int ieee80211_ocb_join(struct ieee80211_sub_if_data *sdata,
		       struct ocb_setup *setup);
int ieee80211_ocb_leave(struct ieee80211_sub_if_data *sdata);

1533 1534 1535 1536
/* 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);
1537
int ieee80211_mesh_csa_beacon(struct ieee80211_sub_if_data *sdata,
1538
			      struct cfg80211_csa_settings *csa_settings);
1539
int ieee80211_mesh_finish_csa(struct ieee80211_sub_if_data *sdata);
1540

J
Johannes Berg 已提交
1541
/* scan/BSS handling */
1542
void ieee80211_scan_work(struct work_struct *work);
S
Stanislaw Gruszka 已提交
1543 1544
int ieee80211_request_ibss_scan(struct ieee80211_sub_if_data *sdata,
				const u8 *ssid, u8 ssid_len,
1545 1546
				struct ieee80211_channel **channels,
				unsigned int n_channels,
1547
				enum nl80211_bss_scan_width scan_width);
1548
int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
1549
			   struct cfg80211_scan_request *req);
1550
void ieee80211_scan_cancel(struct ieee80211_local *local);
1551
void ieee80211_run_deferred_scan(struct ieee80211_local *local);
J
Johannes Berg 已提交
1552
void ieee80211_scan_rx(struct ieee80211_local *local, struct sk_buff *skb);
J
Johannes Berg 已提交
1553

1554
void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local);
1555
struct ieee80211_bss *
1556 1557 1558 1559 1560
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,
1561
			  struct ieee80211_channel *channel);
1562
void ieee80211_rx_bss_put(struct ieee80211_local *local,
1563
			  struct ieee80211_bss *bss);
1564

1565
/* scheduled scan handling */
1566 1567 1568
int
__ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
				     struct cfg80211_sched_scan_request *req);
1569 1570
int ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
				       struct cfg80211_sched_scan_request *req);
1571
int ieee80211_request_sched_scan_stop(struct ieee80211_sub_if_data *sdata);
1572
void ieee80211_sched_scan_end(struct ieee80211_local *local);
1573
void ieee80211_sched_scan_stopped_work(struct work_struct *work);
1574

1575
/* off-channel helpers */
1576 1577
void ieee80211_offchannel_stop_vifs(struct ieee80211_local *local);
void ieee80211_offchannel_return(struct ieee80211_local *local);
1578 1579
void ieee80211_roc_setup(struct ieee80211_local *local);
void ieee80211_start_next_roc(struct ieee80211_local *local);
1580 1581
void ieee80211_roc_purge(struct ieee80211_local *local,
			 struct ieee80211_sub_if_data *sdata);
1582
void ieee80211_roc_notify_destroy(struct ieee80211_roc_work *roc, bool free);
1583 1584
void ieee80211_sw_roc_work(struct work_struct *work);
void ieee80211_handle_roc_started(struct ieee80211_roc_work *roc);
1585

1586 1587
/* channel switch handling */
void ieee80211_csa_finalize_work(struct work_struct *work);
1588 1589
int ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
			     struct cfg80211_csa_settings *params);
1590

1591
/* interface handling */
1592 1593
int ieee80211_iface_init(void);
void ieee80211_iface_exit(void);
1594
int ieee80211_if_add(struct ieee80211_local *local, const char *name,
1595
		     unsigned char name_assign_type,
1596
		     struct wireless_dev **new_wdev, enum nl80211_iftype type,
1597
		     struct vif_params *params);
1598
int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
1599
			     enum nl80211_iftype type);
1600
void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata);
1601
void ieee80211_remove_interfaces(struct ieee80211_local *local);
1602
u32 ieee80211_idle_off(struct ieee80211_local *local);
J
Johannes Berg 已提交
1603
void ieee80211_recalc_idle(struct ieee80211_local *local);
1604 1605
void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
				    const int offset);
1606 1607
int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up);
void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata);
1608 1609
int ieee80211_add_virtual_monitor(struct ieee80211_local *local);
void ieee80211_del_virtual_monitor(struct ieee80211_local *local);
1610

1611
bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata);
1612 1613
void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata,
			      bool update_bss);
1614

1615 1616
static inline bool ieee80211_sdata_running(struct ieee80211_sub_if_data *sdata)
{
1617
	return test_bit(SDATA_STATE_RUNNING, &sdata->state);
1618 1619
}

1620 1621 1622
/* tx handling */
void ieee80211_clear_tx_pending(struct ieee80211_local *local);
void ieee80211_tx_pending(unsigned long data);
1623 1624 1625 1626
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);
1627 1628 1629
void __ieee80211_subif_start_xmit(struct sk_buff *skb,
				  struct net_device *dev,
				  u32 info_flags);
1630 1631
void ieee80211_purge_tx_queue(struct ieee80211_hw *hw,
			      struct sk_buff_head *skbs);
1632 1633 1634
struct sk_buff *
ieee80211_build_data_template(struct ieee80211_sub_if_data *sdata,
			      struct sk_buff *skb, u32 info_flags);
1635

1636
/* HT */
B
Ben Greear 已提交
1637 1638
void ieee80211_apply_htcap_overrides(struct ieee80211_sub_if_data *sdata,
				     struct ieee80211_sta_ht_cap *ht_cap);
1639
bool ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_sub_if_data *sdata,
B
Ben Greear 已提交
1640
				       struct ieee80211_supported_band *sband,
J
Johannes Berg 已提交
1641
				       const struct ieee80211_ht_cap *ht_cap_ie,
1642
				       struct sta_info *sta);
J
Johannes Berg 已提交
1643 1644 1645
void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata,
			  const u8 *da, u16 tid,
			  u16 initiator, u16 reason_code);
1646 1647 1648
int ieee80211_send_smps_action(struct ieee80211_sub_if_data *sdata,
			       enum ieee80211_smps_mode smps, const u8 *da,
			       const u8 *bssid);
1649 1650 1651 1652
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);
1653

1654
void ___ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
1655
				     u16 initiator, u16 reason, bool stop);
1656
void __ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
1657
				    u16 initiator, u16 reason, bool stop);
1658 1659 1660
void __ieee80211_start_rx_ba_session(struct sta_info *sta,
				     u8 dialog_token, u16 timeout,
				     u16 start_seq_num, u16 ba_policy, u16 tid,
1661
				     u16 buf_size, bool tx, bool auto_seq);
1662 1663
void ieee80211_sta_tear_down_BA_sessions(struct sta_info *sta,
					 enum ieee80211_agg_stop_reason reason);
1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675
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);

1676
int __ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
1677
				   enum ieee80211_agg_stop_reason reason);
J
Johannes Berg 已提交
1678
int ___ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
1679
				    enum ieee80211_agg_stop_reason reason);
1680 1681
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 已提交
1682 1683
void ieee80211_ba_session_work(struct work_struct *work);
void ieee80211_tx_ba_session_handle_start(struct sta_info *sta, int tid);
1684
void ieee80211_release_reorder_timeout(struct sta_info *sta, int tid);
1685

1686 1687
u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs);

M
Mahesh Palivela 已提交
1688
/* VHT */
J
Johannes Berg 已提交
1689 1690 1691 1692 1693
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);
1694
enum ieee80211_sta_rx_bandwidth ieee80211_sta_cap_rx_bw(struct sta_info *sta);
1695
enum ieee80211_sta_rx_bandwidth ieee80211_sta_cur_vht_bw(struct sta_info *sta);
1696
void ieee80211_sta_set_rx_nss(struct sta_info *sta);
1697 1698 1699
u32 __ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
                                  struct sta_info *sta, u8 opmode,
                                  enum ieee80211_band band, bool nss_only);
1700 1701
void ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
				 struct sta_info *sta, u8 opmode,
1702
				 enum ieee80211_band band, bool nss_only);
1703 1704
void ieee80211_apply_vhtcap_overrides(struct ieee80211_sub_if_data *sdata,
				      struct ieee80211_sta_vht_cap *vht_cap);
1705

1706 1707 1708 1709
/* Spectrum management */
void ieee80211_process_measurement_req(struct ieee80211_sub_if_data *sdata,
				       struct ieee80211_mgmt *mgmt,
				       size_t len);
1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721
/**
 * ieee80211_parse_ch_switch_ie - parses channel switch IEs
 * @sdata: the sdata of the interface which has received the frame
 * @elems: parsed 802.11 elements received with the frame
 * @current_band: indicates the current band
 * @sta_flags: contains information about own capabilities and restrictions
 *	to decide which channel switch announcements can be accepted. Only the
 *	following subset of &enum ieee80211_sta_flags are evaluated:
 *	%IEEE80211_STA_DISABLE_HT, %IEEE80211_STA_DISABLE_VHT,
 *	%IEEE80211_STA_DISABLE_40MHZ, %IEEE80211_STA_DISABLE_80P80MHZ,
 *	%IEEE80211_STA_DISABLE_160MHZ.
 * @bssid: the currently connected bssid (for reporting)
1722 1723
 * @csa_ie: parsed 802.11 csa elements on count, mode, chandef and mesh ttl.
	All of them will be filled with if success only.
1724 1725 1726
 * 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,
1727
				 struct ieee802_11_elems *elems,
1728
				 enum ieee80211_band current_band,
1729 1730
				 u32 sta_flags, u8 *bssid,
				 struct ieee80211_csa_ie *csa_ie);
1731

1732 1733
/* Suspend/resume and hw reconfiguration */
int ieee80211_reconfig(struct ieee80211_local *local);
1734
void ieee80211_stop_device(struct ieee80211_local *local);
1735

1736 1737
int __ieee80211_suspend(struct ieee80211_hw *hw,
			struct cfg80211_wowlan *wowlan);
1738 1739 1740

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

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

1748 1749
	return ieee80211_reconfig(hw_to_local(hw));
}
1750

J
Johannes Berg 已提交
1751
/* utility functions/constants */
1752
extern const void *const mac80211_wiphy_privid; /* for wiphy privid */
1753
u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
1754
			enum nl80211_iftype type);
1755
int ieee80211_frame_duration(enum ieee80211_band band, size_t len,
1756 1757
			     int rate, int erp, int short_preamble,
			     int shift);
1758
void mac80211_ev_michael_mic_failure(struct ieee80211_sub_if_data *sdata, int keyidx,
1759 1760
				     struct ieee80211_hdr *hdr, const u8 *tsc,
				     gfp_t gfp);
1761 1762
void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
			       bool bss_notify);
1763 1764
void ieee80211_xmit(struct ieee80211_sub_if_data *sdata,
		    struct sta_info *sta, struct sk_buff *skb);
J
Johannes Berg 已提交
1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778

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();
}
1779

J
Johannes Berg 已提交
1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
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,
1794
				    chanctx_conf->def.chan->band);
J
Johannes Berg 已提交
1795 1796 1797 1798
	rcu_read_unlock();
}

static inline void ieee80211_tx_skb(struct ieee80211_sub_if_data *sdata,
1799 1800 1801 1802 1803 1804
				    struct sk_buff *skb)
{
	/* Send all internal mgmt frames on VO. Accordingly set TID to 7. */
	ieee80211_tx_skb_tid(sdata, skb, 7);
}

1805
u32 ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
1806 1807
			       struct ieee802_11_elems *elems,
			       u64 filter, u32 crc);
1808 1809
static inline void ieee802_11_parse_elems(const u8 *start, size_t len,
					  bool action,
1810 1811
					  struct ieee802_11_elems *elems)
{
1812
	ieee802_11_parse_elems_crc(start, len, action, elems, 0, 0);
1813 1814
}

1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
static inline bool ieee80211_rx_reorder_ready(struct sk_buff_head *frames)
{
	struct sk_buff *tail = skb_peek_tail(frames);
	struct ieee80211_rx_status *status;

	if (!tail)
		return false;

	status = IEEE80211_SKB_RXCB(tail);
	if (status->flag & RX_FLAG_AMSDU_MORE)
		return false;

	return true;
}

1830 1831 1832 1833 1834 1835 1836
extern const int ieee802_1d_to_ac[8];

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

1837 1838 1839
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);
1840 1841 1842
void ieee80211_send_nullfunc(struct ieee80211_local *local,
			     struct ieee80211_sub_if_data *sdata,
			     int powersave);
1843 1844
void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
			     struct ieee80211_hdr *hdr);
1845
void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata,
1846
			     struct ieee80211_hdr *hdr, bool ack, u16 tx_time);
1847

K
Kalle Valo 已提交
1848
void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
1849
				     unsigned long queues,
1850 1851
				     enum queue_stop_reason reason,
				     bool refcounted);
1852 1853 1854 1855 1856 1857
void ieee80211_stop_vif_queues(struct ieee80211_local *local,
			       struct ieee80211_sub_if_data *sdata,
			       enum queue_stop_reason reason);
void ieee80211_wake_vif_queues(struct ieee80211_local *local,
			       struct ieee80211_sub_if_data *sdata,
			       enum queue_stop_reason reason);
K
Kalle Valo 已提交
1858
void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
1859
				     unsigned long queues,
1860 1861
				     enum queue_stop_reason reason,
				     bool refcounted);
1862
void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
1863 1864
				    enum queue_stop_reason reason,
				    bool refcounted);
1865
void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
1866 1867
				    enum queue_stop_reason reason,
				    bool refcounted);
1868
void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue);
1869 1870
void ieee80211_add_pending_skb(struct ieee80211_local *local,
			       struct sk_buff *skb);
1871 1872
void ieee80211_add_pending_skbs(struct ieee80211_local *local,
				struct sk_buff_head *skbs);
1873
void ieee80211_flush_queues(struct ieee80211_local *local,
1874
			    struct ieee80211_sub_if_data *sdata, bool drop);
1875 1876
void __ieee80211_flush_queues(struct ieee80211_local *local,
			      struct ieee80211_sub_if_data *sdata,
1877
			      unsigned int queues, bool drop);
K
Kalle Valo 已提交
1878

1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908
static inline bool ieee80211_can_run_worker(struct ieee80211_local *local)
{
	/*
	 * If quiescing is set, we are racing with __ieee80211_suspend.
	 * __ieee80211_suspend flushes the workers after setting quiescing,
	 * and we check quiescing / suspended before enqueing new workers.
	 * We should abort the worker to avoid the races below.
	 */
	if (local->quiescing)
		return false;

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

	return true;
}

1909
void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
1910
			 u16 transaction, u16 auth_alg, u16 status,
J
Johannes Berg 已提交
1911
			 const u8 *extra, size_t extra_len, const u8 *bssid,
1912 1913
			 const u8 *da, const u8 *key, u8 key_len, u8 key_idx,
			 u32 tx_flags);
1914 1915 1916
void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
				    const u8 *bssid, u16 stype, u16 reason,
				    bool send_frame, u8 *frame_buf);
1917
int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
1918 1919 1920 1921
			     size_t buffer_len,
			     struct ieee80211_scan_ies *ie_desc,
			     const u8 *ie, size_t ie_len,
			     u8 bands_used, u32 *rate_masks,
1922
			     struct cfg80211_chan_def *chandef);
1923
struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
1924 1925
					  const u8 *src, const u8 *dst,
					  u32 ratemask,
1926
					  struct ieee80211_channel *chan,
1927
					  const u8 *ssid, size_t ssid_len,
1928 1929
					  const u8 *ie, size_t ie_len,
					  bool directed);
1930 1931
void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata,
			      const u8 *src, const u8 *dst,
1932
			      const u8 *ssid, size_t ssid_len,
1933
			      const u8 *ie, size_t ie_len,
1934
			      u32 ratemask, bool directed, u32 tx_flags,
J
Johannes Berg 已提交
1935
			      struct ieee80211_channel *channel, bool scan);
1936

1937
u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata,
1938
			    struct ieee802_11_elems *elems,
1939
			    enum ieee80211_band band, u32 *basic_rates);
1940 1941 1942 1943
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);
1944
void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata);
1945
void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata);
1946

1947 1948 1949 1950
size_t ieee80211_ie_split_ric(const u8 *ies, size_t ielen,
			      const u8 *ids, int n_ids,
			      const u8 *after_ric, int n_after_ric,
			      size_t offset);
1951
size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset);
B
Ben Greear 已提交
1952
u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
1953
			      u16 cap);
1954
u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
1955
			       const struct cfg80211_chan_def *chandef,
1956
			       u16 prot_mode);
1957 1958
u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
			       u32 cap);
1959 1960
u8 *ieee80211_ie_build_vht_oper(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
				const struct cfg80211_chan_def *chandef);
1961 1962 1963
int ieee80211_parse_bitrates(struct cfg80211_chan_def *chandef,
			     const struct ieee80211_supported_band *sband,
			     const u8 *srates, int srates_len, u32 *rates);
1964
int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata,
1965 1966
			    struct sk_buff *skb, bool need_basic,
			    enum ieee80211_band band);
1967
int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata,
1968 1969
				struct sk_buff *skb, bool need_basic,
				enum ieee80211_band band);
1970
u8 *ieee80211_add_wmm_info_ie(u8 *buf, u8 qosinfo);
1971

1972
/* channel management */
1973
void ieee80211_ht_oper_to_chandef(struct ieee80211_channel *control_chan,
J
Johannes Berg 已提交
1974
				  const struct ieee80211_ht_operation *ht_oper,
1975
				  struct cfg80211_chan_def *chandef);
1976 1977 1978
void ieee80211_vht_oper_to_chandef(struct ieee80211_channel *control_chan,
				   const struct ieee80211_vht_operation *oper,
				   struct cfg80211_chan_def *chandef);
1979
u32 ieee80211_chandef_downgrade(struct cfg80211_chan_def *c);
1980

1981 1982
int __must_check
ieee80211_vif_use_channel(struct ieee80211_sub_if_data *sdata,
1983
			  const struct cfg80211_chan_def *chandef,
1984
			  enum ieee80211_chanctx_mode mode);
1985 1986 1987
int __must_check
ieee80211_vif_reserve_chanctx(struct ieee80211_sub_if_data *sdata,
			      const struct cfg80211_chan_def *chandef,
1988 1989
			      enum ieee80211_chanctx_mode mode,
			      bool radar_required);
1990
int __must_check
1991
ieee80211_vif_use_reserved_context(struct ieee80211_sub_if_data *sdata);
1992 1993
int ieee80211_vif_unreserve_chanctx(struct ieee80211_sub_if_data *sdata);

1994 1995 1996 1997
int __must_check
ieee80211_vif_change_bandwidth(struct ieee80211_sub_if_data *sdata,
			       const struct cfg80211_chan_def *chandef,
			       u32 *changed);
1998
void ieee80211_vif_release_channel(struct ieee80211_sub_if_data *sdata);
1999
void ieee80211_vif_vlan_copy_chanctx(struct ieee80211_sub_if_data *sdata);
2000 2001
void ieee80211_vif_copy_chanctx_to_vlans(struct ieee80211_sub_if_data *sdata,
					 bool clear);
2002 2003
int ieee80211_chanctx_refcount(struct ieee80211_local *local,
			       struct ieee80211_chanctx *ctx);
2004

2005 2006
void ieee80211_recalc_smps_chanctx(struct ieee80211_local *local,
				   struct ieee80211_chanctx *chanctx);
2007 2008
void ieee80211_recalc_chanctx_min_def(struct ieee80211_local *local,
				      struct ieee80211_chanctx *ctx);
2009
bool ieee80211_is_radar_required(struct ieee80211_local *local);
2010 2011 2012 2013 2014

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);
2015 2016
int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
			      struct cfg80211_csa_settings *csa_settings);
2017

2018 2019 2020 2021 2022 2023 2024 2025
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);
2026 2027
void ieee80211_recalc_dtim(struct ieee80211_local *local,
			   struct ieee80211_sub_if_data *sdata);
2028 2029 2030 2031
int ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata,
				 const struct cfg80211_chan_def *chandef,
				 enum ieee80211_chanctx_mode chanmode,
				 u8 radar_detect);
2032
int ieee80211_max_num_channels(struct ieee80211_local *local);
2033

2034 2035
/* TDLS */
int ieee80211_tdls_mgmt(struct wiphy *wiphy, struct net_device *dev,
2036
			const u8 *peer, u8 action_code, u8 dialog_token,
2037
			u16 status_code, u32 peer_capability,
2038 2039
			bool initiator, const u8 *extra_ies,
			size_t extra_ies_len);
2040
int ieee80211_tdls_oper(struct wiphy *wiphy, struct net_device *dev,
2041
			const u8 *peer, enum nl80211_tdls_operation oper);
J
Johannes Berg 已提交
2042
void ieee80211_tdls_peer_del_work(struct work_struct *wk);
2043 2044 2045 2046 2047 2048
int ieee80211_tdls_channel_switch(struct wiphy *wiphy, struct net_device *dev,
				  const u8 *addr, u8 oper_class,
				  struct cfg80211_chan_def *chandef);
void ieee80211_tdls_cancel_channel_switch(struct wiphy *wiphy,
					  struct net_device *dev,
					  const u8 *addr);
2049 2050
void ieee80211_process_tdls_channel_switch(struct ieee80211_sub_if_data *sdata,
					   struct sk_buff *skb);
2051

2052 2053
extern const struct ethtool_ops ieee80211_ethtool_ops;

2054
#ifdef CONFIG_MAC80211_NOINLINE
2055 2056 2057 2058 2059
#define debug_noinline noinline
#else
#define debug_noinline
#endif

2060
#endif /* IEEE80211_I_H */