ieee80211_i.h 65.4 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

Johannes Berg's avatar
Johannes Berg committed
37
38
extern const struct cfg80211_ops mac80211_config_ops;

39
struct ieee80211_local;
40
41
42
43
44
45
46
47
48
49
50
51

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

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

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

63
/*
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 * 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.
80
 */
81
#define IEEE80211_DEFAULT_UAPSD_QUEUES 0
82
83
84
85

#define IEEE80211_DEFAULT_MAX_SP_LEN		\
	IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL

86
87
#define IEEE80211_DEAUTH_FRAME_LEN	(24 /* hdr */ + 2 /* reason */)

88
89
struct ieee80211_fragment_entry {
	struct sk_buff_head skb_list;
90
91
92
93
94
	unsigned long first_frag_time;
	u16 seq;
	u16 extra_len;
	u16 last_frag;
	u8 rx_queue;
95
	bool check_sequential_pn; /* needed for CCMP/GCMP */
96
97
98
99
	u8 last_pn[6]; /* PN of the last fragment if CCMP was used */
};


100
struct ieee80211_bss {
101
	u32 device_ts_beacon, device_ts_presp;
102

103
	bool wmm_used;
104
	bool uapsd_supported;
105

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

111
	/*
Lucas De Marchi's avatar
Lucas De Marchi committed
112
	 * During association, we save an ERP value from a probe response so
113
114
	 * that we can feed ERP info to the driver when handling the
	 * association completes. these fields probably won't be up-to-date
115
116
117
	 * otherwise, you probably don't want to use them.
	 */
	bool has_erp_value;
118
	u8 erp_value;
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
146
147

	/* 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
148
 * of the data structure were received as a result of an un-corrupted
149
150
151
152
153
154
 * 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)
155
156
};

157
158
159
160
161
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)

162
163
164
165
166
#define IEEE80211_TX_UNICAST		BIT(1)
#define IEEE80211_TX_PS_BUFFERED	BIT(2)

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

174
	unsigned int flags;
175
176
177
};


178
typedef unsigned __bitwise__ ieee80211_rx_result;
Johannes Berg's avatar
Johannes Berg committed
179
180
181
182
#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)
183

184
185
186
187
/**
 * enum ieee80211_packet_rx_flags - packet RX flags
 * @IEEE80211_RX_AMSDU: a-MSDU packet
 * @IEEE80211_RX_MALFORMED_ACTION_FRM: action frame is malformed
188
 * @IEEE80211_RX_DEFERRED_RELEASE: frame was subjected to receive reordering
189
190
191
192
193
194
195
 *
 * 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),
196
	IEEE80211_RX_DEFERRED_RELEASE		= BIT(5),
197
198
199
200
201
202
};

/**
 * enum ieee80211_rx_flags - RX data flags
 *
 * @IEEE80211_RX_CMNTR: received on cooked monitor already
Johannes Berg's avatar
Johannes Berg committed
203
204
 * @IEEE80211_RX_BEACON_REPORTED: This frame was already reported
 *	to cfg80211_report_obss_beacon().
205
206
207
208
209
210
 *
 * 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
211
	IEEE80211_RX_BEACON_REPORTED	= BIT(1),
212
};
213
214

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

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

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

239
240
	u32 tkip_iv32;
	u16 tkip_iv16;
241
242
};

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

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

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

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

281
282
283
284
struct ieee80211_if_ap {
	struct beacon_data __rcu *beacon;
	struct probe_resp __rcu *probe_resp;

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

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

	struct work_struct request_smps_work;
295
296
};

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

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

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

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

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

326
struct ieee80211_roc_work {
327
	struct list_head list;
328
329
330

	struct ieee80211_sub_if_data *sdata;

331
	struct ieee80211_channel *chan;
332

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

336
	unsigned long 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
421
DECLARE_EWMA(beacon_signal, 16, 4)

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
	struct ewma_beacon_signal ave_beacon_signal;
494

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

502
503
504
	/* Number of times beacon loss was invoked. */
	unsigned int beacon_loss_count;

505
506
507
508
509
510
	/*
	 * 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;
511
512
513
514
515
516
517
518

	/*
	 * 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;
519
520
521

	struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
	struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */
522
523
	struct ieee80211_vht_cap vht_capa; /* configured VHT overrides */
	struct ieee80211_vht_cap vht_capa_mask; /* Valid parts of vht_capa */
524

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

	/* 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;
543
544
};

545
546
struct ieee80211_if_ibss {
	struct timer_list timer;
547
	struct work_struct csa_connection_drop_work;
548

549
	unsigned long last_scan_completed;
550

551
552
	u32 basic_rates;

553
554
	bool fixed_bssid;
	bool fixed_channel;
Johannes Berg's avatar
Johannes Berg committed
555
	bool privacy;
556

557
	bool control_port;
558
	bool userspace_handles_dfs;
559

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

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

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

573
574
575
	spinlock_t incomplete_lock;
	struct list_head incomplete_stations;

576
577
578
579
580
581
	enum {
		IEEE80211_IBSS_MLME_SEARCH,
		IEEE80211_IBSS_MLME_JOINED,
	} state;
};

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

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

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

622
623
624
625
626
struct mesh_csa_settings {
	struct rcu_head rcu_head;
	struct cfg80211_csa_settings settings;
};

627
628
629
struct ieee80211_if_mesh {
	struct timer_list housekeeping_timer;
	struct timer_list mesh_path_timer;
630
	struct timer_list mesh_path_root_timer;
631

632
	unsigned long wrkq_flags;
633
	unsigned long mbss_changed;
634
635
636
637

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

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

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

709
710
711
712
713
714
715
716
/**
 * 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.
717
 * @IEEE80211_SDATA_DISCONNECT_RESUME: Disconnect after resume.
718
 * @IEEE80211_SDATA_IN_DRIVER: indicates interface was added to driver
719
720
721
 */
enum ieee80211_sub_if_data_flags {
	IEEE80211_SDATA_ALLMULTI		= BIT(0),
722
723
	IEEE80211_SDATA_OPERATING_GMODE		= BIT(2),
	IEEE80211_SDATA_DONT_BRIDGE_PACKETS	= BIT(3),
724
	IEEE80211_SDATA_DISCONNECT_RESUME	= BIT(4),
725
	IEEE80211_SDATA_IN_DRIVER		= BIT(5),
726
727
};

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

744
745
746
747
748
749
750
751
752
753
754
755
756
757
/**
 * 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
};

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

776
777
778
779
struct ieee80211_chanctx {
	struct list_head list;
	struct rcu_head rcu_head;

780
	struct list_head assigned_vifs;
781
	struct list_head reserved_vifs;
782

783
784
785
	enum ieee80211_chanctx_replace_state replace_state;
	struct ieee80211_chanctx *replace_ctx;

786
	enum ieee80211_chanctx_mode mode;
787
	bool driver_present;
788
789
790
791

	struct ieee80211_chanctx_conf conf;
};

792
793
794
795
796
struct mac80211_qos_map {
	struct cfg80211_qos_map qos_map;
	struct rcu_head rcu_head;
};

797
798
799
800
801
802
803
804
enum txq_info_flags {
	IEEE80211_TXQ_STOP,
	IEEE80211_TXQ_AMPDU,
};

struct txq_info {
	struct sk_buff_head queue;
	unsigned long flags;
805
	unsigned long byte_cnt;
806
807
808
809
810

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

811
812
813
814
815
struct ieee80211_sub_if_data {
	struct list_head list;

	struct wireless_dev wdev;

816
817
818
	/* keys */
	struct list_head key_list;

819
820
	/* count for keys needing tailroom space allocation */
	int crypto_tx_tailroom_needed_cnt;
821
822
	int crypto_tx_tailroom_pending_dec;
	struct delayed_work dec_tailroom_needed_wk;
823

824
825
826
	struct net_device *dev;
	struct ieee80211_local *local;

827
	unsigned int flags;
828

829
830
	unsigned long state;

831
832
	char name[IFNAMSIZ];

833
834
835
836
	/* Fragment table for host-based reassembly */
	struct ieee80211_fragment_entry	fragments[IEEE80211_FRAGMENT_MAX];
	unsigned int fragment_next;

837
838
839
	/* TID bitmap for NoAck policy */
	u16 noack_map;

840
841
842
	/* bit field of ACM bits (BIT(802.1D tag)) */
	u8 wmm_acm;

843
844
845
846
	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;
847

848
	u16 sequence_number;
849
850
	__be16 control_port_protocol;
	bool control_port_no_encrypt;
851
	int encrypt_headroom;
852

853
	atomic_t txqs_len[IEEE80211_NUM_ACS];
854
	struct ieee80211_tx_queue_params tx_conf[IEEE80211_NUM_ACS];
855
	struct mac80211_qos_map __rcu *qos_map;
856

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

861
	struct list_head assigned_chanctx_list; /* protected by chanctx_mtx */
862
	struct list_head reserved_chanctx_list; /* protected by chanctx_mtx */
863

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

870
871
872
	/* used to reconfigure hardware SM PS */
	struct work_struct recalc_smps;

873
	struct work_struct work;
Johannes Berg's avatar
Johannes Berg committed
874
875
	struct sk_buff_head skb_queue;

876
877
878
	u8 needed_rx_chains;
	enum ieee80211_smps_mode smps_mode;

879
880
881
	int user_power_level; /* in dBm */
	int ap_power_level; /* in dBm */

882
883
884
	bool radar_required;
	struct delayed_work dfs_cac_timer_work;

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

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

	bool rc_has_mcs_mask[IEEE80211_NUM_BANDS];
896
	u8  rc_rateidx_mcs_mask[IEEE80211_NUM_BANDS][IEEE80211_HT_MCS_MASK_LEN];
897

898
899
900
	bool rc_has_vht_mcs_mask[IEEE80211_NUM_BANDS];
	u16 rc_rateidx_vht_mcs_mask[IEEE80211_NUM_BANDS][NL80211_VHT_NSS_MAX];

901
902
903
904
	union {
		struct ieee80211_if_ap ap;
		struct ieee80211_if_wds wds;
		struct ieee80211_if_vlan vlan;
905
906
		struct ieee80211_if_managed mgd;
		struct ieee80211_if_ibss ibss;
907
		struct ieee80211_if_mesh mesh;
908
		struct ieee80211_if_ocb ocb;
909
		u32 mntr_flags;
910
	} u;
911
912

#ifdef CONFIG_MAC80211_DEBUGFS
913
	struct {
914
		struct dentry *subdir_stations;
915
916
		struct dentry *default_unicast_key;
		struct dentry *default_multicast_key;
917
		struct dentry *default_mgmt_key;
918
	} debugfs;
919
#endif
920

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

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

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

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

948
949
950
951
952
953
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
954
955
956
957
958
959
960
961
962
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))
963
		band = chanctx_conf->def.chan->band;
Johannes Berg's avatar
Johannes Berg committed
964
965
966
967
968
	rcu_read_unlock();

	return band;
}

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

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

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

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

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,
1028
1029
};

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

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

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

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

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

1104
	unsigned long queue_stop_reasons[IEEE80211_MAX_QUEUES];
1105
	int q_stop_reasons[IEEE80211_MAX_QUEUES][IEEE80211_QUEUE_STOP_REASONS];
1106
	/* also used to protect ampdu_ac_queue and amdpu_ac_stop_refcnt */
1107
	spinlock_t queue_stop_reason_lock;
1108

1109
	int open_count;
1110
	int monitors, cooked_mntrs;
1111
	/* number of interfaces with corresponding FIF_ flags */
1112
1113
1114
	int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss, fif_pspoll,
	    fif_probe_req;
	int probe_req_reg;
1115
	unsigned int filter_flags; /* FIF_* */
Johannes Berg's avatar
Johannes Berg committed
1116

1117