ieee80211_i.h 65.2 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>
28
#include <linux/idr.h>
29
#include <linux/rhashtable.h>
30
#include <net/ieee80211_radiotap.h>
31
#include <net/cfg80211.h>
32
#include <net/mac80211.h>
Johannes Berg's avatar
Johannes Berg committed
33
#include "key.h"
34
#include "sta_info.h"
Johannes Berg's avatar
Johannes Berg committed
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
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
struct ieee80211_fragment_entry {
	struct sk_buff_head skb_list;
88 89 90 91 92 93
	unsigned long first_frag_time;
	u16 seq;
	u16 extra_len;
	u16 last_frag;
	u8 rx_queue;
	bool ccmp; /* Whether fragments were encrypted with CCMP */
94 95 96 97
	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;
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
	/*
Lucas De Marchi's avatar
Lucas De Marchi committed
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;
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
146
 * of the data structure were received as a result of an un-corrupted
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;
Johannes Berg's avatar
Johannes Berg committed
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
/**
 * enum ieee80211_packet_rx_flags - packet RX flags
 * @IEEE80211_RX_AMSDU: a-MSDU packet
 * @IEEE80211_RX_MALFORMED_ACTION_FRM: action frame is malformed
186
 * @IEEE80211_RX_DEFERRED_RELEASE: frame was subjected to receive reordering
187 188 189 190 191 192 193
 *
 * These are per-frame flags that are attached to a frame in the
 * @rx_flags field of &struct ieee80211_rx_status.
 */
enum ieee80211_packet_rx_flags {
	IEEE80211_RX_AMSDU			= BIT(3),
	IEEE80211_RX_MALFORMED_ACTION_FRM	= BIT(4),
194
	IEEE80211_RX_DEFERRED_RELEASE		= BIT(5),
195 196 197 198 199 200
};

/**
 * enum ieee80211_rx_flags - RX data flags
 *
 * @IEEE80211_RX_CMNTR: received on cooked monitor already
Johannes Berg's avatar
Johannes Berg committed
201 202
 * @IEEE80211_RX_BEACON_REPORTED: This frame was already reported
 *	to cfg80211_report_obss_beacon().
203 204 205 206 207 208
 *
 * These flags are used across handling multiple interfaces
 * for a single frame.
 */
enum ieee80211_rx_flags {
	IEEE80211_RX_CMNTR		= BIT(0),
Johannes Berg's avatar
Johannes Berg committed
209
	IEEE80211_RX_BEACON_REPORTED	= BIT(1),
210
};
211 212

struct ieee80211_rx_data {
213
	struct napi_struct *napi;
214 215 216 217 218
	struct sk_buff *skb;
	struct ieee80211_local *local;
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;
	struct ieee80211_key *key;
219 220

	unsigned int flags;
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236

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

237 238
	u32 tkip_iv32;
	u16 tkip_iv16;
239 240
};

241 242 243 244 245 246 247 248 249 250
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;
};

251 252 253
struct beacon_data {
	u8 *head, *tail;
	int head_len, tail_len;
254
	struct ieee80211_meshconf_ie *meshconf;
255 256
	u16 csa_counter_offsets[IEEE80211_MAX_CSA_COUNTERS_NUM];
	u8 csa_current_counter;
257
	struct rcu_head rcu_head;
258 259
};

260 261 262
struct probe_resp {
	struct rcu_head rcu_head;
	int len;
263
	u16 csa_counter_offsets[IEEE80211_MAX_CSA_COUNTERS_NUM];
264 265 266
	u8 data[0];
};

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

279 280 281 282
struct ieee80211_if_ap {
	struct beacon_data __rcu *beacon;
	struct probe_resp __rcu *probe_resp;

283 284
	/* to be used after channel switch. */
	struct cfg80211_beacon_data *next_beacon;
285
	struct list_head vlans; /* write-protected with RTNL and local->mtx */
286 287 288

	struct ps_data ps;
	atomic_t num_mcast_sta; /* number of stations receiving multicast */
289 290 291 292
	enum ieee80211_smps_mode req_smps, /* requested smps mode */
			 driver_smps_mode; /* smps mode request */

	struct work_struct request_smps_work;
293 294
};

295 296
struct ieee80211_if_wds {
	struct sta_info *sta;
297
	u8 remote_addr[ETH_ALEN];
298 299 300
};

struct ieee80211_if_vlan {
301
	struct list_head list; /* write-protected with RTNL and local->mtx */
302 303

	/* used for all tx if the VLAN is configured to 4-addr mode */
304
	struct sta_info __rcu *sta;
305 306
};

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

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

324
struct ieee80211_roc_work {
325
	struct list_head list;
326
	struct list_head dependents;
327

328
	struct delayed_work work;
329 330 331

	struct ieee80211_sub_if_data *sdata;

332
	struct ieee80211_channel *chan;
333

334
	bool started, abort, hw_begun, notified;
335
	bool to_be_freed;
336
	bool on_channel;
337

338
	unsigned long hw_start_time;
339

340 341
	u32 duration, req_duration;
	struct sk_buff *frame;
342
	u64 cookie, mgmt_tx_cookie;
343
	enum ieee80211_roc_type type;
344 345
};

346
/* flags used in struct ieee80211_if_managed.flags */
347
enum ieee80211_sta_flags {
348 349
	IEEE80211_STA_CONNECTION_POLL	= BIT(1),
	IEEE80211_STA_CONTROL_PORT	= BIT(2),
350
	IEEE80211_STA_DISABLE_HT	= BIT(4),
351
	IEEE80211_STA_MFP_ENABLED	= BIT(6),
352
	IEEE80211_STA_UAPSD_ENABLED	= BIT(7),
353
	IEEE80211_STA_NULLFUNC_ACKED	= BIT(8),
354
	IEEE80211_STA_RESET_SIGNAL_AVE	= BIT(9),
355
	IEEE80211_STA_DISABLE_40MHZ	= BIT(10),
356
	IEEE80211_STA_DISABLE_VHT	= BIT(11),
357 358
	IEEE80211_STA_DISABLE_80P80MHZ	= BIT(12),
	IEEE80211_STA_DISABLE_160MHZ	= BIT(13),
359
	IEEE80211_STA_DISABLE_WMM	= BIT(14),
360
	IEEE80211_STA_ENABLE_RRM	= BIT(15),
361 362
};

Johannes Berg's avatar
Johannes Berg committed
363 364 365 366 367 368 369 370 371
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;
372
	bool timeout_started;
Johannes Berg's avatar
Johannes Berg committed
373

374 375 376
	u16 sae_trans, sae_status;
	size_t data_len;
	u8 data[];
Johannes Berg's avatar
Johannes Berg committed
377 378 379 380 381 382 383 384 385 386 387 388 389 390
};

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;
391
	bool wmm, uapsd;
392
	bool need_beacon;
Johannes Berg's avatar
Johannes Berg committed
393
	bool synced;
394
	bool timeout_started;
Johannes Berg's avatar
Johannes Berg committed
395

396 397
	u8 ap_ht_param;

398 399
	struct ieee80211_vht_cap ap_vht_cap;

Johannes Berg's avatar
Johannes Berg committed
400 401 402 403
	size_t ie_len;
	u8 ie[];
};

404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
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;
};

422
struct ieee80211_if_managed {
423
	struct timer_list timer;
424 425
	struct timer_list conn_mon_timer;
	struct timer_list bcn_mon_timer;
Sujith's avatar
Sujith committed
426
	struct timer_list chswitch_timer;
427
	struct work_struct monitor_work;
Sujith's avatar
Sujith committed
428
	struct work_struct chswitch_work;
429
	struct work_struct beacon_connection_loss_work;
430
	struct work_struct csa_connection_drop_work;
431

432
	unsigned long beacon_timeout;
433
	unsigned long probe_timeout;
434
	int probe_send_count;
435
	bool nullfunc_failed;
436
	bool connection_loss;
437

438
	struct cfg80211_bss *associated;
Johannes Berg's avatar
Johannes Berg committed
439 440
	struct ieee80211_mgd_auth_data *auth_data;
	struct ieee80211_mgd_assoc_data *assoc_data;
441

442
	u8 bssid[ETH_ALEN];
443

444 445
	u16 aid;

446
	bool powersave; /* powersave requested for this iface */
447
	bool broken_ap; /* AP is broken -- turn off powersave */
448
	bool have_beacon;
449
	u8 dtim_period;
450
	enum ieee80211_smps_mode req_smps, /* requested smps mode */
451 452 453
				 driver_smps_mode; /* smps mode request */

	struct work_struct request_smps_work;
454

455
	unsigned int flags;
456

457
	bool csa_waiting_bcn;
458
	bool csa_ignored_same_chan;
459

460
	bool beacon_crc_valid;
461 462
	u32 beacon_crc;

463 464 465 466
	bool status_acked;
	bool status_received;
	__le16 status_fc;

467 468 469 470 471 472
	enum {
		IEEE80211_MFP_DISABLED,
		IEEE80211_MFP_OPTIONAL,
		IEEE80211_MFP_REQUIRED
	} mfp; /* management frame protection */

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

487
	int wmm_last_param_set;
488 489

	u8 use_4addr;
490

491
	s16 p2p_noa_index;
492

493 494 495 496 497 498 499 500
	/*
	 * 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;

501 502 503 504 505 506 507
	/*
	 * 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;

508 509 510 511 512 513
	/*
	 * 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;
514 515 516 517 518 519 520 521

	/*
	 * 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;
522 523 524

	struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
	struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */
525 526
	struct ieee80211_vht_cap vht_capa; /* configured VHT overrides */
	struct ieee80211_vht_cap vht_capa_mask; /* Valid parts of vht_capa */
527

528
	/* TDLS support */
529 530
	u8 tdls_peer[ETH_ALEN] __aligned(2);
	struct delayed_work tdls_peer_del_work;
531 532 533
	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 */
534
	bool tdls_chan_switch_prohibited;
535
	bool tdls_wider_bw_prohibited;
536 537 538 539 540 541 542 543 544 545

	/* 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;
546 547
};

548 549
struct ieee80211_if_ibss {
	struct timer_list timer;
550
	struct work_struct csa_connection_drop_work;
551

552
	unsigned long last_scan_completed;
553

554 555
	u32 basic_rates;

556 557
	bool fixed_bssid;
	bool fixed_channel;
Johannes Berg's avatar
Johannes Berg committed
558
	bool privacy;
559

560
	bool control_port;
561
	bool userspace_handles_dfs;
562

563
	u8 bssid[ETH_ALEN] __aligned(2);
564 565 566
	u8 ssid[IEEE80211_MAX_SSID_LEN];
	u8 ssid_len, ie_len;
	u8 *ie;
567
	struct cfg80211_chan_def chandef;
568 569

	unsigned long ibss_join_req;
570
	/* probe response/beacon for IBSS */
571
	struct beacon_data __rcu *presp;
572

573 574 575
	struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
	struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */

576 577 578
	spinlock_t incomplete_lock;
	struct list_head incomplete_stations;

579 580 581 582 583 584
	enum {
		IEEE80211_IBSS_MLME_SEARCH,
		IEEE80211_IBSS_MLME_JOINED,
	} state;
};

585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
/**
 * 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;
};

604 605 606 607 608 609 610 611 612 613 614 615 616 617
/**
 * 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);
618 619 620 621

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

625 626 627 628 629
struct mesh_csa_settings {
	struct rcu_head rcu_head;
	struct cfg80211_csa_settings settings;
};

630 631 632
struct ieee80211_if_mesh {
	struct timer_list housekeeping_timer;
	struct timer_list mesh_path_timer;
633
	struct timer_list mesh_path_root_timer;
634

635
	unsigned long wrkq_flags;
636
	unsigned long mbss_changed;
637 638 639 640

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

	/* offset from skb->data while building IE */
	int meshconf_offset;
702
};
Johannes Berg's avatar
Johannes Berg committed
703 704

#ifdef CONFIG_MAC80211_MESH
705 706
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name)	\
	do { (msh)->mshstats.name++; } while (0)
Johannes Berg's avatar
Johannes Berg committed
707
#else
708
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \
Johannes Berg's avatar
Johannes Berg committed
709 710
	do { } while (0)
#endif
711

712 713 714 715 716 717 718 719
/**
 * enum ieee80211_sub_if_data_flags - virtual interface flags
 *
 * @IEEE80211_SDATA_ALLMULTI: interface wants all multicast packets
 * @IEEE80211_SDATA_OPERATING_GMODE: operating in G-only mode
 * @IEEE80211_SDATA_DONT_BRIDGE_PACKETS: bridge packets between
 *	associated stations and deliver multicast frames both
 *	back to wireless media and to the local net stack.
720
 * @IEEE80211_SDATA_DISCONNECT_RESUME: Disconnect after resume.
721
 * @IEEE80211_SDATA_IN_DRIVER: indicates interface was added to driver
722
 * @IEEE80211_SDATA_MU_MIMO_OWNER: indicates interface owns MU-MIMO capability
723 724 725
 */
enum ieee80211_sub_if_data_flags {
	IEEE80211_SDATA_ALLMULTI		= BIT(0),
726 727
	IEEE80211_SDATA_OPERATING_GMODE		= BIT(2),
	IEEE80211_SDATA_DONT_BRIDGE_PACKETS	= BIT(3),
728
	IEEE80211_SDATA_DISCONNECT_RESUME	= BIT(4),
729
	IEEE80211_SDATA_IN_DRIVER		= BIT(5),
730
	IEEE80211_SDATA_MU_MIMO_OWNER		= BIT(6),
731 732
};

733 734 735 736 737
/**
 * 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
738 739
 * @SDATA_STATE_OFFCHANNEL: This interface is currently in offchannel
 *	mode, so queues are stopped
740 741
 * @SDATA_STATE_OFFCHANNEL_BEACON_STOPPED: Beaconing was stopped due
 *	to offchannel, reset when offchannel returns
742 743 744
 */
enum ieee80211_sdata_state_bits {
	SDATA_STATE_RUNNING,
745
	SDATA_STATE_OFFCHANNEL,
746
	SDATA_STATE_OFFCHANNEL_BEACON_STOPPED,
747 748
};

749 750 751 752 753 754 755 756 757 758 759 760 761 762
/**
 * 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
};

763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780
/**
 * 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,
};

781 782 783 784
struct ieee80211_chanctx {
	struct list_head list;
	struct rcu_head rcu_head;

785
	struct list_head assigned_vifs;
786
	struct list_head reserved_vifs;
787

788 789 790
	enum ieee80211_chanctx_replace_state replace_state;
	struct ieee80211_chanctx *replace_ctx;

791
	enum ieee80211_chanctx_mode mode;
792
	bool driver_present;
793 794 795 796

	struct ieee80211_chanctx_conf conf;
};

797 798 799 800 801
struct mac80211_qos_map {
	struct cfg80211_qos_map qos_map;
	struct rcu_head rcu_head;
};

802 803 804 805 806 807 808 809 810 811 812 813 814
enum txq_info_flags {
	IEEE80211_TXQ_STOP,
	IEEE80211_TXQ_AMPDU,
};

struct txq_info {
	struct sk_buff_head queue;
	unsigned long flags;

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

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

	struct wireless_dev wdev;

820 821 822
	/* keys */
	struct list_head key_list;

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

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

831
	unsigned int flags;
832

833 834
	unsigned long state;

835 836
	char name[IFNAMSIZ];

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

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

844 845 846
	/* bit field of ACM bits (BIT(802.1D tag)) */
	u8 wmm_acm;

847 848 849 850
	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;
851

852
	u16 sequence_number;
853 854
	__be16 control_port_protocol;
	bool control_port_no_encrypt;
855
	int encrypt_headroom;
856

857
	atomic_t txqs_len[IEEE80211_NUM_ACS];
858
	struct ieee80211_tx_queue_params tx_conf[IEEE80211_NUM_ACS];
859
	struct mac80211_qos_map __rcu *qos_map;
860

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

865
	struct list_head assigned_chanctx_list; /* protected by chanctx_mtx */
866
	struct list_head reserved_chanctx_list; /* protected by chanctx_mtx */
867

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

874 875 876
	/* used to reconfigure hardware SM PS */
	struct work_struct recalc_smps;

877
	struct work_struct work;
Johannes Berg's avatar
Johannes Berg committed
878 879
	struct sk_buff_head skb_queue;

880 881 882
	u8 needed_rx_chains;
	enum ieee80211_smps_mode smps_mode;

883 884 885
	int user_power_level; /* in dBm */
	int ap_power_level; /* in dBm */

886 887 888
	bool radar_required;
	struct delayed_work dfs_cac_timer_work;

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

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

	bool rc_has_mcs_mask[IEEE80211_NUM_BANDS];
900
	u8  rc_rateidx_mcs_mask[IEEE80211_NUM_BANDS][IEEE80211_HT_MCS_MASK_LEN];
901

902 903 904
	bool rc_has_vht_mcs_mask[IEEE80211_NUM_BANDS];
	u16 rc_rateidx_vht_mcs_mask[IEEE80211_NUM_BANDS][NL80211_VHT_NSS_MAX];

905 906 907 908
	union {
		struct ieee80211_if_ap ap;
		struct ieee80211_if_wds wds;
		struct ieee80211_if_vlan vlan;
909 910
		struct ieee80211_if_managed mgd;
		struct ieee80211_if_ibss ibss;
911
		struct ieee80211_if_mesh mesh;
912
		struct ieee80211_if_ocb ocb;
913
		u32 mntr_flags;
914
	} u;
915 916

#ifdef CONFIG_MAC80211_DEBUGFS
917
	struct {
918
		struct dentry *subdir_stations;
919 920
		struct dentry *default_unicast_key;
		struct dentry *default_multicast_key;
921
		struct dentry *default_mgmt_key;
922
	} debugfs;
923
#endif
924

925 926
	/* must be last, dynamically sized area in this! */
	struct ieee80211_vif vif;
927 928
};

929 930 931 932 933 934
static inline
struct ieee80211_sub_if_data *vif_to_sdata(struct ieee80211_vif *p)
{
	return container_of(p, struct ieee80211_sub_if_data, vif);
}

935 936 937 938 939 940 941 942 943 944 945 946 947 948
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);
}

949 950 951
#define sdata_dereference(p, sdata) \
	rcu_dereference_protected(p, lockdep_is_held(&sdata->wdev.mtx))

952 953 954 955 956 957
static inline void
sdata_assert_lock(struct ieee80211_sub_if_data *sdata)
{
	lockdep_assert_held(&sdata->wdev.mtx);
}

Johannes Berg's avatar
Johannes Berg committed
958 959 960