ieee80211_i.h 64.7 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 <net/ieee80211_radiotap.h>
30
#include <net/cfg80211.h>
31
#include <net/mac80211.h>
Johannes Berg's avatar
Johannes Berg committed
32
#include "key.h"
33
#include "sta_info.h"
Johannes Berg's avatar
Johannes Berg committed
34
#include "debug.h"
35

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

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

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

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

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

#define IEEE80211_DEFAULT_MAX_SP_LEN		\
	IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL

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

74
75
76
77
78
79
80
81
82
83
84
85
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 */
};


86
struct ieee80211_bss {
87
	u32 device_ts_beacon, device_ts_presp;
88

89
	bool wmm_used;
90
	bool uapsd_supported;
91

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

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

	/* 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
134
 * of the data structure were received as a result of an un-corrupted
135
136
137
138
139
140
 * 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)
141
142
};

143
144
145
146
147
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)

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

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

160
	unsigned int flags;
161
162
163
};


164
typedef unsigned __bitwise__ ieee80211_rx_result;
Johannes Berg's avatar
Johannes Berg committed
165
166
167
168
#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)
169

170
171
172
173
174
175
176
/**
 * 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
177
 * @IEEE80211_RX_DEFERRED_RELEASE: frame was subjected to receive reordering
178
179
180
181
182
183
184
185
186
 *
 * 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),
187
	IEEE80211_RX_DEFERRED_RELEASE		= BIT(5),
188
189
190
191
192
193
};

/**
 * enum ieee80211_rx_flags - RX data flags
 *
 * @IEEE80211_RX_CMNTR: received on cooked monitor already
Johannes Berg's avatar
Johannes Berg committed
194
195
 * @IEEE80211_RX_BEACON_REPORTED: This frame was already reported
 *	to cfg80211_report_obss_beacon().
196
197
198
199
200
201
 *
 * 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
202
	IEEE80211_RX_BEACON_REPORTED	= BIT(1),
203
};
204
205

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

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

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

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

233
234
235
236
237
238
239
240
241
242
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;
};

243
244
245
struct beacon_data {
	u8 *head, *tail;
	int head_len, tail_len;
246
	struct ieee80211_meshconf_ie *meshconf;
247
248
	u16 csa_counter_offsets[IEEE80211_MAX_CSA_COUNTERS_NUM];
	u8 csa_current_counter;
249
	struct rcu_head rcu_head;
250
251
};

252
253
254
struct probe_resp {
	struct rcu_head rcu_head;
	int len;
255
	u16 csa_counter_offsets[IEEE80211_MAX_CSA_COUNTERS_NUM];
256
257
258
	u8 data[0];
};

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

271
272
273
274
struct ieee80211_if_ap {
	struct beacon_data __rcu *beacon;
	struct probe_resp __rcu *probe_resp;

275
276
	/* to be used after channel switch. */
	struct cfg80211_beacon_data *next_beacon;
277
	struct list_head vlans; /* write-protected with RTNL and local->mtx */
278
279
280

	struct ps_data ps;
	atomic_t num_mcast_sta; /* number of stations receiving multicast */
281
282
283
284
	enum ieee80211_smps_mode req_smps, /* requested smps mode */
			 driver_smps_mode; /* smps mode request */

	struct work_struct request_smps_work;
285
286
};

287
288
struct ieee80211_if_wds {
	struct sta_info *sta;
289
	u8 remote_addr[ETH_ALEN];
290
291
292
};

struct ieee80211_if_vlan {
293
	struct list_head list; /* write-protected with RTNL and local->mtx */
294
295

	/* used for all tx if the VLAN is configured to 4-addr mode */
296
	struct sta_info __rcu *sta;
297
298
};

299
struct mesh_stats {
300
301
302
	__u32 fwded_mcast;		/* Mesh forwarded multicast frames */
	__u32 fwded_unicast;		/* Mesh forwarded unicast frames */
	__u32 fwded_frames;		/* Mesh total forwarded frames */
303
304
	__u32 dropped_frames_ttl;	/* Not transmitted since mesh_ttl == 0*/
	__u32 dropped_frames_no_route;	/* Not transmitted, no route found */
305
	__u32 dropped_frames_congestion;/* Not forwarded due to congestion */
306
307
308
309
310
311
312
313
314
315
};

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

316
317
318
319
320
#if HZ/100 == 0
#define IEEE80211_ROC_MIN_LEFT	1
#else
#define IEEE80211_ROC_MIN_LEFT	(HZ/100)
#endif
321

322
struct ieee80211_roc_work {
323
	struct list_head list;
324
	struct list_head dependents;
325

326
	struct delayed_work work;
327
328
329

	struct ieee80211_sub_if_data *sdata;

330
	struct ieee80211_channel *chan;
331

332
	bool started, abort, hw_begun, notified;
333
	bool to_be_freed;
334
	bool on_channel;
335

336
	unsigned long hw_start_time;
337

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

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

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

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

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

394
395
	u8 ap_ht_param;

396
397
	struct ieee80211_vht_cap ap_vht_cap;

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

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

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

430
	unsigned long beacon_timeout;
431
	unsigned long probe_timeout;
432
	int probe_send_count;
433
	bool nullfunc_failed;
434
	bool connection_loss;
435

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

440
	u8 bssid[ETH_ALEN];
441

442
443
	u16 aid;

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

	struct work_struct request_smps_work;
452

453
	unsigned int flags;
454

455
456
	bool csa_waiting_bcn;

457
	bool beacon_crc_valid;
458
459
	u32 beacon_crc;

460
461
462
463
	bool status_acked;
	bool status_received;
	__le16 status_fc;

464
465
466
467
468
469
	enum {
		IEEE80211_MFP_DISABLED,
		IEEE80211_MFP_OPTIONAL,
		IEEE80211_MFP_REQUIRED
	} mfp; /* management frame protection */

470
471
472
473
474
475
476
477
478
479
480
481
482
483
	/*
	 * 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;

484
	int wmm_last_param_set;
485
486

	u8 use_4addr;
487

488
	s16 p2p_noa_index;
489

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

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
536
537
538
539
540
541
542
543
544

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

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

551
	unsigned long last_scan_completed;
552

553
554
	u32 basic_rates;

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

559
	bool control_port;
560
	bool userspace_handles_dfs;
561

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

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

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

575
576
577
	spinlock_t incomplete_lock;
	struct list_head incomplete_stations;

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

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

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

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

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

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

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

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

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

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

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_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.
720
 * @IEEE80211_SDATA_DISCONNECT_RESUME: Disconnect after resume.
721
 * @IEEE80211_SDATA_IN_DRIVER: indicates interface was added to driver
722
723
724
725
 */
enum ieee80211_sub_if_data_flags {
	IEEE80211_SDATA_ALLMULTI		= BIT(0),
	IEEE80211_SDATA_PROMISC			= BIT(1),
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
731
};

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

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

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

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

784
	struct list_head assigned_vifs;
785
	struct list_head reserved_vifs;
786

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

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

	struct ieee80211_chanctx_conf conf;
};

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

801
802
803
804
805
struct ieee80211_sub_if_data {
	struct list_head list;

	struct wireless_dev wdev;

806
807
808
	/* keys */
	struct list_head key_list;

809
810
	/* count for keys needing tailroom space allocation */
	int crypto_tx_tailroom_needed_cnt;
811
812
	int crypto_tx_tailroom_pending_dec;
	struct delayed_work dec_tailroom_needed_wk;
813

814
815
816
	struct net_device *dev;
	struct ieee80211_local *local;

817
	unsigned int flags;
818

819
820
	unsigned long state;

821
822
	int drop_unencrypted;

823
824
	char name[IFNAMSIZ];

825
826
827
828
	/* Fragment table for host-based reassembly */
	struct ieee80211_fragment_entry	fragments[IEEE80211_FRAGMENT_MAX];
	unsigned int fragment_next;

829
830
831
	/* TID bitmap for NoAck policy */
	u16 noack_map;

832
833
834
	/* bit field of ACM bits (BIT(802.1D tag)) */
	u8 wmm_acm;

835
836
837
838
	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;
839

840
	u16 sequence_number;
841
842
	__be16 control_port_protocol;
	bool control_port_no_encrypt;
843
	int encrypt_headroom;
844

845
	struct ieee80211_tx_queue_params tx_conf[IEEE80211_NUM_ACS];
846
	struct mac80211_qos_map __rcu *qos_map;
847

848
	struct work_struct csa_finalize_work;
849
	bool csa_block_tx; /* write-protected by sdata_lock and local->mtx */
850
	struct cfg80211_chan_def csa_chandef;
851

852
	struct list_head assigned_chanctx_list; /* protected by chanctx_mtx */
853
	struct list_head reserved_chanctx_list; /* protected by chanctx_mtx */
854

855
856
857
	/* context reservation -- protected with chanctx_mtx */
	struct ieee80211_chanctx *reserved_chanctx;
	struct cfg80211_chan_def reserved_chandef;
858
	bool reserved_radar_required;
859
	bool reserved_ready;
860

861
862
863
	/* used to reconfigure hardware SM PS */
	struct work_struct recalc_smps;

864
	struct work_struct work;
Johannes Berg's avatar
Johannes Berg committed
865
866
	struct sk_buff_head skb_queue;

867
868
869
	u8 needed_rx_chains;
	enum ieee80211_smps_mode smps_mode;

870
871
872
	int user_power_level; /* in dBm */
	int ap_power_level; /* in dBm */

873
874
875
	bool radar_required;
	struct delayed_work dfs_cac_timer_work;

876
	/*
877
878
879
	 * AP this belongs to: self in AP mode and
	 * corresponding AP in VLAN mode, NULL for
	 * all others (might be needed later in IBSS)
880
	 */
881
882
	struct ieee80211_if_ap *bss;

883
884
	/* bitmap of allowed (non-MCS) rate indexes for rate control */
	u32 rc_rateidx_mask[IEEE80211_NUM_BANDS];
885
886

	bool rc_has_mcs_mask[IEEE80211_NUM_BANDS];
887
	u8  rc_rateidx_mcs_mask[IEEE80211_NUM_BANDS][IEEE80211_HT_MCS_MASK_LEN];
888
889
890
891
892

	union {
		struct ieee80211_if_ap ap;
		struct ieee80211_if_wds wds;
		struct ieee80211_if_vlan vlan;
893
894
		struct ieee80211_if_managed mgd;
		struct ieee80211_if_ibss ibss;
895
		struct ieee80211_if_mesh mesh;
896
		struct ieee80211_if_ocb ocb;
897
		u32 mntr_flags;
898
	} u;
899
900

#ifdef CONFIG_MAC80211_DEBUGFS
901
	struct {
902
		struct dentry *subdir_stations;
903
904
		struct dentry *default_unicast_key;
		struct dentry *default_multicast_key;
905
		struct dentry *default_mgmt_key;
906
	} debugfs;
907
#endif
908

909
910
	/* must be last, dynamically sized area in this! */
	struct ieee80211_vif vif;
911
912
};

913
914
915
916
917
918
static inline
struct ieee80211_sub_if_data *vif_to_sdata(struct ieee80211_vif *p)
{
	return container_of(p, struct ieee80211_sub_if_data, vif);
}

919
920
921
922
923
924
925
926
927
928
929
930
931
932
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);
}

933
934
935
#define sdata_dereference(p, sdata) \
	rcu_dereference_protected(p, lockdep_is_held(&sdata->wdev.mtx))

936
937
938
939
940
941
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
942
943
944
945
946
947
948
949
950
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))
951
		band = chanctx_conf->def.chan->band;
Johannes Berg's avatar
Johannes Berg committed
952
953
954
955
956
	rcu_read_unlock();

	return band;
}

957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
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;
}

985
986
987
988
989
struct ieee80211_rx_agg {
	u8 addr[ETH_ALEN];
	u16 tid;
};

990
991
992
993
enum sdata_queue_type {
	IEEE80211_SDATA_QUEUE_TYPE_FRAME	= 0,
	IEEE80211_SDATA_QUEUE_AGG_START		= 1,
	IEEE80211_SDATA_QUEUE_AGG_STOP		= 2,
994
995
	IEEE80211_SDATA_QUEUE_RX_AGG_START	= 3,
	IEEE80211_SDATA_QUEUE_RX_AGG_STOP	= 4,
996
	IEEE80211_SDATA_QUEUE_TDLS_CHSW		= 5,
997
998
};

999
1000
1001
1002
1003
enum {
	IEEE80211_RX_MSG	= 1,
	IEEE80211_TX_STATUS_MSG	= 2,
};

1004
1005
enum queue_stop_reason {
	IEEE80211_QUEUE_STOP_REASON_DRIVER,
1006
	IEEE80211_QUEUE_STOP_REASON_PS,
1007
1008
	IEEE80211_QUEUE_STOP_REASON_CSA,
	IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
1009
	IEEE80211_QUEUE_STOP_REASON_SUSPEND,
1010
	IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
1011
	IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL,
1012
	IEEE80211_QUEUE_STOP_REASON_FLUSH,
1013
	IEEE80211_QUEUE_STOP_REASON_TDLS_TEARDOWN,
1014
	IEEE80211_QUEUE_STOP_REASON_RESERVE_TID,
1015
1016

	IEEE80211_QUEUE_STOP_REASONS,
1017
1018
};

1019
#ifdef CONFIG_MAC80211_LEDS
1020
1021
1022
1023
1024
1025
1026
1027
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;
1028
1029
	unsigned int active, want;
	bool running;
1030
};
1031
#endif
1032

1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
/*
 * struct ieee80211_tx_latency_bin_ranges - Tx latency statistics bins ranges
 *
 * Measuring Tx latency statistics. Counts how many Tx frames transmitted in a
 * certain latency range (in Milliseconds). Each station that uses these
 * ranges will have bins to count the amount of frames received in that range.
 * The user can configure the ranges via debugfs.
 * If ranges is NULL then Tx latency statistics bins are disabled for all
 * stations.
 *
 * @n_ranges: number of ranges that are taken in account
 * @ranges: the ranges that the user requested or NULL if disabled.
 */
struct ieee80211_tx_latency_bin_ranges {
	int n_ranges;
	u32 ranges[];
};

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

/**
 * 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
1084
1085
1086
 * @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
1087
 * @SCAN_ABORT: Abort the scan and go back to operating channel
1088
1089
1090
1091
1092
 */
enum mac80211_scan_state {
	SCAN_DECISION,
	SCAN_SET_CHANNEL,
	SCAN_SEND_PROBE,
1093
1094
	SCAN_SUSPEND,
	SCAN_RESUME,
1095
	SCAN_ABORT,
1096
1097
};

1098
1099
1100
1101
1102
1103
1104
1105
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;

1106
1107
1108
1109
1110
1111
	/*
	 * private workqueue to mac80211. mac80211 makes this accessible
	 * via ieee80211_queue_work()
	 */
	struct workqueue_struct *workqueue;

1112
	unsigned long queue_stop_reasons[IEEE80211_MAX_QUEUES];
1113
	int q_stop_reasons[IEEE80211_MAX_QUEUES][IEEE80211_QUEUE_STOP_REASONS];
1114
	/* also used to protect ampdu_ac_queue and amdpu_ac_stop_refcnt */
1115
	spinlock_t queue_stop_reason_lock;
1116

1117
	int open_count;
1118
	int monitors, cooked_mntrs;
1119
	/* number of interfaces with corresponding FIF_ flags */
1120
1121
1122
	int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss, fif_pspoll,
	    fif_probe_req;
	int probe_req_reg;
1123
	unsigned int filter_flags; /* FIF_* */
Johannes Berg's avatar
Johannes Berg committed
1124

1125
1126
	bool wiphy_ciphers_allocated;

1127
1128
	bool use_chanctx;

Johannes Berg's avatar
Johannes Berg committed
1129
1130
1131
	/* protects the aggregated multicast list and filter calls */
	spinlock_t filter_lock;

1132
1133
1134
	/* used for uploading changed mc list */
	struct work_struct reconfig_filter;

Johannes Berg's avatar
Johannes Berg committed
1135
	/* aggregated multicast list */
1136
	struct netdev_hw_addr_list mc_list;
Johannes Berg's avatar
Johannes Berg committed
1137

1138
	bool tim_in_locked_section; /* see ieee80211_beacon_get() */
1139
1140
1141
1142
1143
1144
1145
1146
1147

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

Johannes Berg's avatar
Johannes Berg committed
1148
1149
1150
1151
1152
1153
1154
1155
	/*
	 * 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;

1156
1157
1158
1159
1160
1161
	/*
	 * quiescing is true during the suspend process _only_ to
	 * ease timer cancelling etc.
	 */
	bool quiescing;

1162
1163
1164
	/* device is started */
	bool started;

1165
1166