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

#ifndef IEEE80211_I_H
#define IEEE80211_I_H

#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/if_ether.h>
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/workqueue.h>
#include <linux/types.h>
#include <linux/spinlock.h>
25
#include <linux/etherdevice.h>
26
#include <linux/leds.h>
27
#include <linux/idr.h>
28
#include <net/ieee80211_radiotap.h>
29
#include <net/cfg80211.h>
30
#include <net/mac80211.h>
Johannes Berg's avatar
Johannes Berg committed
31
#include "key.h"
32
#include "sta_info.h"
Johannes Berg's avatar
Johannes Berg committed
33
#include "debug.h"
34

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

/* Maximum number of broadcast/multicast frames to buffer when some of the
 * associated stations are using power saving. */
#define AP_MAX_BC_BUFFER 128

/* Maximum number of frames buffered to all STAs, including multicast frames.
 * Note: increasing this limit increases the potential memory requirement. Each
 * frame can be up to about 2 kB long. */
#define TOTAL_MAX_TX_BUFFER 512

/* Required encryption head and tailroom */
#define IEEE80211_ENCRYPT_HEADROOM 8
48
#define IEEE80211_ENCRYPT_TAILROOM 18
49
50
51
52
53
54
55

/* IEEE 802.11 (Ch. 9.5 Defragmentation) requires support for concurrent
 * reception of at least three fragmented frames. This limit can be increased
 * by changing this define, at the cost of slower frame reassembly and
 * increased memory use (about 2 kB of RAM per entry). */
#define IEEE80211_FRAGMENT_MAX 4

56
57
#define TU_TO_JIFFIES(x)	(usecs_to_jiffies((x) * 1024))
#define TU_TO_EXP_TIME(x)	(jiffies + TU_TO_JIFFIES(x))
58

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

62
63
64
65
66
67
/*
 * 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.
 */
68
#define IEEE80211_DEFAULT_UAPSD_QUEUES \
69
	IEEE80211_WMM_IE_STA_QOSINFO_AC_VO
70
71
72
73

#define IEEE80211_DEFAULT_MAX_SP_LEN		\
	IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL

74
75
#define IEEE80211_DEAUTH_FRAME_LEN	(24 /* hdr */ + 2 /* reason */)

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


88
struct ieee80211_bss {
89
90
	/* don't want to look up all the time */
	size_t ssid_len;
91
	u8 ssid[IEEE80211_MAX_SSID_LEN];
92

93
94
	u32 device_ts;

95
	u8 dtim_period;
96

97
	bool wmm_used;
98
	bool uapsd_supported;
99
100
101

	unsigned long last_probe_resp;

102
103
104
#ifdef CONFIG_MAC80211_MESH
	u8 *mesh_id;
	size_t mesh_id_len;
105
	u8 *mesh_cfg;
Johannes Berg's avatar
Johannes Berg committed
106
#endif
107

108
109
110
111
#define IEEE80211_MAX_SUPP_RATES 32
	u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
	size_t supp_rates_len;

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

	/* 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_DTIM: DTIM data was gathered from non-corrupt IE
 * @IEEE80211_BSS_VALID_WMM: WMM/UAPSD data was gathered from non-corrupt IE
 * @IEEE80211_BSS_VALID_RATES: Supported rates were gathered from non-corrupt IE
 * @IEEE80211_BSS_VALID_ERP: ERP flag was gathered from non-corrupt IE
 *
 * These are bss flags that are attached to a bss in the
 * @valid_data field of &struct ieee80211_bss.  They show which parts
 * of the data structure were recieved as a result of an un-corrupted
 * beacon/probe response.
 */
enum ieee80211_bss_valid_data_flags {
	IEEE80211_BSS_VALID_DTIM		= BIT(0),
	IEEE80211_BSS_VALID_WMM			= BIT(1),
	IEEE80211_BSS_VALID_RATES		= BIT(2),
	IEEE80211_BSS_VALID_ERP			= BIT(3)
158
159
};

160
static inline u8 *bss_mesh_cfg(struct ieee80211_bss *bss)
Johannes Berg's avatar
Johannes Berg committed
161
162
163
164
165
166
167
{
#ifdef CONFIG_MAC80211_MESH
	return bss->mesh_cfg;
#endif
	return NULL;
}

168
static inline u8 *bss_mesh_id(struct ieee80211_bss *bss)
Johannes Berg's avatar
Johannes Berg committed
169
170
171
172
173
174
175
{
#ifdef CONFIG_MAC80211_MESH
	return bss->mesh_id;
#endif
	return NULL;
}

176
static inline u8 bss_mesh_id_len(struct ieee80211_bss *bss)
Johannes Berg's avatar
Johannes Berg committed
177
178
179
180
181
182
183
{
#ifdef CONFIG_MAC80211_MESH
	return bss->mesh_id_len;
#endif
	return 0;
}

184

185
186
187
188
189
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)

190
191
192
193
194
#define IEEE80211_TX_UNICAST		BIT(1)
#define IEEE80211_TX_PS_BUFFERED	BIT(2)

struct ieee80211_tx_data {
	struct sk_buff *skb;
195
	struct sk_buff_head skbs;
196
197
198
199
200
	struct ieee80211_local *local;
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;
	struct ieee80211_key *key;

201
	unsigned int flags;
202
203
204
};


205
typedef unsigned __bitwise__ ieee80211_rx_result;
Johannes Berg's avatar
Johannes Berg committed
206
207
208
209
#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)
210

211
212
213
214
215
216
217
/**
 * 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
218
 * @IEEE80211_RX_DEFERRED_RELEASE: frame was subjected to receive reordering
219
220
221
222
223
224
225
226
227
 *
 * 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),
228
	IEEE80211_RX_DEFERRED_RELEASE		= BIT(5),
229
230
231
232
233
234
};

/**
 * enum ieee80211_rx_flags - RX data flags
 *
 * @IEEE80211_RX_CMNTR: received on cooked monitor already
Johannes Berg's avatar
Johannes Berg committed
235
236
 * @IEEE80211_RX_BEACON_REPORTED: This frame was already reported
 *	to cfg80211_report_obss_beacon().
237
238
239
240
241
242
 *
 * 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
243
	IEEE80211_RX_BEACON_REPORTED	= BIT(1),
244
};
245
246

struct ieee80211_rx_data {
247
248
249
250
251
	struct sk_buff *skb;
	struct ieee80211_local *local;
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;
	struct ieee80211_key *key;
252
253

	unsigned int flags;
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269

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

270
271
	u32 tkip_iv32;
	u16 tkip_iv16;
272
273
};

274
275
276
struct beacon_data {
	u8 *head, *tail;
	int head_len, tail_len;
277
	struct rcu_head rcu_head;
278
279
};

280
281
282
283
284
285
struct probe_resp {
	struct rcu_head rcu_head;
	int len;
	u8 data[0];
};

286
struct ps_data {
287
288
	/* yes, this looks ugly, but guarantees that we can later use
	 * bitmap_empty :)
289
	 * NB: don't touch this bitmap, use sta_info_{set,clear}_tim_bit */
290
	u8 tim[sizeof(unsigned long) * BITS_TO_LONGS(IEEE80211_MAX_AID + 1)];
291
	struct sk_buff_head bc_buf;
292
	atomic_t num_sta_ps; /* number of stations in PS mode */
293
	int dtim_count;
294
	bool dtim_bc_mc;
295
296
};

297
298
299
300
301
302
303
304
305
306
struct ieee80211_if_ap {
	struct beacon_data __rcu *beacon;
	struct probe_resp __rcu *probe_resp;

	struct list_head vlans;

	struct ps_data ps;
	atomic_t num_mcast_sta; /* number of stations receiving multicast */
};

307
308
struct ieee80211_if_wds {
	struct sta_info *sta;
309
	u8 remote_addr[ETH_ALEN];
310
311
312
};

struct ieee80211_if_vlan {
313
	struct list_head list;
314
315

	/* used for all tx if the VLAN is configured to 4-addr mode */
316
	struct sta_info __rcu *sta;
317
318
};

319
struct mesh_stats {
320
321
322
	__u32 fwded_mcast;		/* Mesh forwarded multicast frames */
	__u32 fwded_unicast;		/* Mesh forwarded unicast frames */
	__u32 fwded_frames;		/* Mesh total forwarded frames */
323
324
	__u32 dropped_frames_ttl;	/* Not transmitted since mesh_ttl == 0*/
	__u32 dropped_frames_no_route;	/* Not transmitted, no route found */
325
	__u32 dropped_frames_congestion;/* Not forwarded due to congestion */
326
327
328
329
330
331
332
333
334
335
};

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

336
337
338
339
340
#if HZ/100 == 0
#define IEEE80211_ROC_MIN_LEFT	1
#else
#define IEEE80211_ROC_MIN_LEFT	(HZ/100)
#endif
341

342
struct ieee80211_roc_work {
343
	struct list_head list;
344
	struct list_head dependents;
345

346
	struct delayed_work work;
347
348
349

	struct ieee80211_sub_if_data *sdata;

350
	struct ieee80211_channel *chan;
351
	enum nl80211_channel_type chan_type;
352

353
	bool started, abort, hw_begun, notified;
354

355
	unsigned long hw_start_time;
356

357
358
	u32 duration, req_duration;
	struct sk_buff *frame;
359
	u64 cookie, mgmt_tx_cookie;
360
361
};

362
/* flags used in struct ieee80211_if_managed.flags */
363
enum ieee80211_sta_flags {
364
365
366
	IEEE80211_STA_BEACON_POLL	= BIT(0),
	IEEE80211_STA_CONNECTION_POLL	= BIT(1),
	IEEE80211_STA_CONTROL_PORT	= BIT(2),
367
	IEEE80211_STA_DISABLE_HT	= BIT(4),
368
369
	IEEE80211_STA_CSA_RECEIVED	= BIT(5),
	IEEE80211_STA_MFP_ENABLED	= BIT(6),
370
	IEEE80211_STA_UAPSD_ENABLED	= BIT(7),
371
	IEEE80211_STA_NULLFUNC_ACKED	= BIT(8),
372
	IEEE80211_STA_RESET_SIGNAL_AVE	= BIT(9),
373
	IEEE80211_STA_DISABLE_40MHZ	= BIT(10),
374
	IEEE80211_STA_DISABLE_VHT	= BIT(11),
375
376
};

Johannes Berg's avatar
Johannes Berg committed
377
378
379
380
381
382
383
384
385
386
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;

387
388
389
	u16 sae_trans, sae_status;
	size_t data_len;
	u8 data[];
Johannes Berg's avatar
Johannes Berg committed
390
391
392
393
394
395
396
397
398
399
400
401
402
403
};

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;
404
	bool wmm, uapsd;
Johannes Berg's avatar
Johannes Berg committed
405
406
407
408
	bool have_beacon;
	bool sent_assoc;
	bool synced;

409
410
	u8 ap_ht_param;

Johannes Berg's avatar
Johannes Berg committed
411
412
413
414
	size_t ie_len;
	u8 ie[];
};

415
struct ieee80211_if_managed {
416
	struct timer_list timer;
417
418
	struct timer_list conn_mon_timer;
	struct timer_list bcn_mon_timer;
Sujith's avatar
Sujith committed
419
	struct timer_list chswitch_timer;
420
	struct work_struct monitor_work;
Sujith's avatar
Sujith committed
421
	struct work_struct chswitch_work;
422
	struct work_struct beacon_connection_loss_work;
423
	struct work_struct csa_connection_drop_work;
424

425
	unsigned long beacon_timeout;
426
	unsigned long probe_timeout;
427
	int probe_send_count;
428
	bool nullfunc_failed;
429

430
	struct mutex mtx;
431
	struct cfg80211_bss *associated;
Johannes Berg's avatar
Johannes Berg committed
432
433
	struct ieee80211_mgd_auth_data *auth_data;
	struct ieee80211_mgd_assoc_data *assoc_data;
434

435
	u8 bssid[ETH_ALEN];
436

437
438
	u16 aid;

439
	unsigned long timers_running; /* used for quiesce/restart */
440
	bool powersave; /* powersave requested for this iface */
441
	bool broken_ap; /* AP is broken -- turn off powersave */
442
	enum ieee80211_smps_mode req_smps, /* requested smps mode */
443
444
445
				 driver_smps_mode; /* smps mode request */

	struct work_struct request_smps_work;
446

447
	unsigned int flags;
448

449
	bool beacon_crc_valid;
450
451
	u32 beacon_crc;

452
453
454
455
456
457
	enum {
		IEEE80211_MFP_DISABLED,
		IEEE80211_MFP_OPTIONAL,
		IEEE80211_MFP_REQUIRED
	} mfp; /* management frame protection */

458
459
460
461
462
463
464
465
466
467
468
469
470
471
	/*
	 * 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;

472
	int wmm_last_param_set;
473
474

	u8 use_4addr;
475

476
477
	u8 p2p_noa_index;

478
479
480
481
482
483
484
485
486
487
488
	/* 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;

489
490
491
492
493
494
495
	/*
	 * 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;

496
497
498
499
500
501
	/*
	 * 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;
502
503
504
505
506
507
508
509

	/*
	 * 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;
510
511
512

	struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
	struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */
513
514
};

515
516
517
struct ieee80211_if_ibss {
	struct timer_list timer;

Johannes Berg's avatar
Johannes Berg committed
518
519
	struct mutex mtx;

520
	unsigned long last_scan_completed;
521

522
523
	u32 basic_rates;

524
525
	bool timer_running;

526
527
	bool fixed_bssid;
	bool fixed_channel;
Johannes Berg's avatar
Johannes Berg committed
528
	bool privacy;
529

530
	bool control_port;
531
	unsigned int auth_frame_registrations;
532

533
	u8 bssid[ETH_ALEN] __aligned(2);
534
535
536
537
	u8 ssid[IEEE80211_MAX_SSID_LEN];
	u8 ssid_len, ie_len;
	u8 *ie;
	struct ieee80211_channel *channel;
538
	enum nl80211_channel_type channel_type;
539
540

	unsigned long ibss_join_req;
541
	/* probe response/beacon for IBSS */
542
543
	struct sk_buff __rcu *presp;
	struct sk_buff *skb;
544

545
546
547
	spinlock_t incomplete_lock;
	struct list_head incomplete_stations;

548
549
550
551
552
553
	enum {
		IEEE80211_IBSS_MLME_SEARCH,
		IEEE80211_IBSS_MLME_JOINED,
	} state;
};

554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
/**
 * 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);
	void (*adjust_tbtt)(struct ieee80211_sub_if_data *sdata);
	/* add other framework functions here */
};

572
573
574
struct ieee80211_if_mesh {
	struct timer_list housekeeping_timer;
	struct timer_list mesh_path_timer;
575
	struct timer_list mesh_path_root_timer;
576

577
578
	unsigned long timers_running;

579
	unsigned long wrkq_flags;
580
581
582
583

	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
584
	u8 mesh_pp_id;
585
	/* Active Path Selection Metric Identifier */
Rui Paulo's avatar
Rui Paulo committed
586
	u8 mesh_pm_id;
587
	/* Congestion Control Mode Identifier */
Rui Paulo's avatar
Rui Paulo committed
588
	u8 mesh_cc_id;
589
	/* Synchronization Protocol Identifier */
Rui Paulo's avatar
Rui Paulo committed
590
	u8 mesh_sp_id;
591
	/* Authentication Protocol Identifier */
Rui Paulo's avatar
Rui Paulo committed
592
	u8 mesh_auth_id;
593
594
	/* Local mesh Sequence Number */
	u32 sn;
595
596
597
	/* Last used PREQ ID */
	u32 preq_id;
	atomic_t mpaths;
598
599
	/* Timestamp of last SN update */
	unsigned long last_sn_update;
600
601
602
	/* Time when it's ok to send next PERR */
	unsigned long next_perr;
	/* Timestamp of last PREQ sent */
603
604
605
606
607
608
609
	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;
610
	atomic_t estab_plinks;
611
612
	u32 mesh_seqnum;
	bool accepting_plinks;
613
	int num_gates;
614
615
	const u8 *ie;
	u8 ie_len;
616
617
618
619
620
	enum {
		IEEE80211_MESH_SEC_NONE = 0x0,
		IEEE80211_MESH_SEC_AUTHED = 0x1,
		IEEE80211_MESH_SEC_SECURED = 0x2,
	} security;
621
	/* Extensible Synchronization Framework */
622
	const struct ieee80211_mesh_sync_ops *sync_ops;
623
624
625
	s64 sync_offset_clockdrift_max;
	spinlock_t sync_offset_lock;
	bool adjusting_tbtt;
626
};
Johannes Berg's avatar
Johannes Berg committed
627
628

#ifdef CONFIG_MAC80211_MESH
629
630
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name)	\
	do { (msh)->mshstats.name++; } while (0)
Johannes Berg's avatar
Johannes Berg committed
631
#else
632
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \
Johannes Berg's avatar
Johannes Berg committed
633
634
	do { } while (0)
#endif
635

636
637
638
639
640
641
642
643
644
/**
 * 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.
645
 * @IEEE80211_SDATA_DISCONNECT_RESUME: Disconnect after resume.
646
 * @IEEE80211_SDATA_IN_DRIVER: indicates interface was added to driver
647
648
649
650
 */
enum ieee80211_sub_if_data_flags {
	IEEE80211_SDATA_ALLMULTI		= BIT(0),
	IEEE80211_SDATA_PROMISC			= BIT(1),
651
652
	IEEE80211_SDATA_OPERATING_GMODE		= BIT(2),
	IEEE80211_SDATA_DONT_BRIDGE_PACKETS	= BIT(3),
653
	IEEE80211_SDATA_DISCONNECT_RESUME	= BIT(4),
654
	IEEE80211_SDATA_IN_DRIVER		= BIT(5),
655
656
};

657
658
659
660
661
/**
 * 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
662
663
 * @SDATA_STATE_OFFCHANNEL: This interface is currently in offchannel
 *	mode, so queues are stopped
664
665
666
 */
enum ieee80211_sdata_state_bits {
	SDATA_STATE_RUNNING,
667
	SDATA_STATE_OFFCHANNEL,
668
669
};

670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
/**
 * enum ieee80211_chanctx_mode - channel context configuration mode
 *
 * @IEEE80211_CHANCTX_SHARED: channel context may be used by
 *	multiple interfaces
 * @IEEE80211_CHANCTX_EXCLUSIVE: channel context can be used
 *	only by a single interface. This can be used for example for
 *	non-fixed channel IBSS.
 */
enum ieee80211_chanctx_mode {
	IEEE80211_CHANCTX_SHARED,
	IEEE80211_CHANCTX_EXCLUSIVE
};

struct ieee80211_chanctx {
	struct list_head list;
	struct rcu_head rcu_head;

	enum ieee80211_chanctx_mode mode;
	int refcount;

	struct ieee80211_chanctx_conf conf;
};

694
695
696
697
698
struct ieee80211_sub_if_data {
	struct list_head list;

	struct wireless_dev wdev;

699
700
701
	/* keys */
	struct list_head key_list;

702
703
704
	/* count for keys needing tailroom space allocation */
	int crypto_tx_tailroom_needed_cnt;

705
706
707
	struct net_device *dev;
	struct ieee80211_local *local;

708
	unsigned int flags;
709

710
711
	unsigned long state;

712
713
	int drop_unencrypted;

714
715
	char name[IFNAMSIZ];

716
717
718
	/* to detect idle changes */
	bool old_idle;

719
720
721
722
	/* Fragment table for host-based reassembly */
	struct ieee80211_fragment_entry	fragments[IEEE80211_FRAGMENT_MAX];
	unsigned int fragment_next;

723
724
725
	/* TID bitmap for NoAck policy */
	u16 noack_map;

726
727
728
	/* bit field of ACM bits (BIT(802.1D tag)) */
	u8 wmm_acm;

729
730
731
732
	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;
733

734
	u16 sequence_number;
735
736
	__be16 control_port_protocol;
	bool control_port_no_encrypt;
737

738
	struct ieee80211_tx_queue_params tx_conf[IEEE80211_NUM_ACS];
739

740
741
742
	/* used to reconfigure hardware SM PS */
	struct work_struct recalc_smps;

743
	struct work_struct work;
Johannes Berg's avatar
Johannes Berg committed
744
745
	struct sk_buff_head skb_queue;

746
747
	bool arp_filter_state;

748
749
750
	u8 needed_rx_chains;
	enum ieee80211_smps_mode smps_mode;

751
752
753
	int user_power_level; /* in dBm */
	int ap_power_level; /* in dBm */

754
	/*
755
756
757
	 * AP this belongs to: self in AP mode and
	 * corresponding AP in VLAN mode, NULL for
	 * all others (might be needed later in IBSS)
758
	 */
759
760
	struct ieee80211_if_ap *bss;

761
762
	/* bitmap of allowed (non-MCS) rate indexes for rate control */
	u32 rc_rateidx_mask[IEEE80211_NUM_BANDS];
763
	u8  rc_rateidx_mcs_mask[IEEE80211_NUM_BANDS][IEEE80211_HT_MCS_MASK_LEN];
764
765
766
767
768

	union {
		struct ieee80211_if_ap ap;
		struct ieee80211_if_wds wds;
		struct ieee80211_if_vlan vlan;
769
770
		struct ieee80211_if_managed mgd;
		struct ieee80211_if_ibss ibss;
771
		struct ieee80211_if_mesh mesh;
772
		u32 mntr_flags;
773
	} u;
774
775

#ifdef CONFIG_MAC80211_DEBUGFS
776
	struct {
777
		struct dentry *dir;
778
		struct dentry *subdir_stations;
779
780
		struct dentry *default_unicast_key;
		struct dentry *default_multicast_key;
781
		struct dentry *default_mgmt_key;
782
	} debugfs;
783
#endif
784
785
	/* must be last, dynamically sized area in this! */
	struct ieee80211_vif vif;
786
787
};

788
789
790
791
792
793
static inline
struct ieee80211_sub_if_data *vif_to_sdata(struct ieee80211_vif *p)
{
	return container_of(p, struct ieee80211_sub_if_data, vif);
}

Johannes Berg's avatar
Johannes Berg committed
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
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))
		band = chanctx_conf->channel->band;
	rcu_read_unlock();

	return band;
}

809
810
811
812
813
814
enum sdata_queue_type {
	IEEE80211_SDATA_QUEUE_TYPE_FRAME	= 0,
	IEEE80211_SDATA_QUEUE_AGG_START		= 1,
	IEEE80211_SDATA_QUEUE_AGG_STOP		= 2,
};

815
816
817
enum {
	IEEE80211_RX_MSG	= 1,
	IEEE80211_TX_STATUS_MSG	= 2,
818
819
820
821
822
	IEEE80211_EOSP_MSG	= 3,
};

struct skb_eosp_msg_data {
	u8 sta[ETH_ALEN], iface[ETH_ALEN];
823
824
};

825
826
enum queue_stop_reason {
	IEEE80211_QUEUE_STOP_REASON_DRIVER,
827
	IEEE80211_QUEUE_STOP_REASON_PS,
828
829
	IEEE80211_QUEUE_STOP_REASON_CSA,
	IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
830
	IEEE80211_QUEUE_STOP_REASON_SUSPEND,
831
	IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
832
833
};

834
#ifdef CONFIG_MAC80211_LEDS
835
836
837
838
839
840
841
842
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;
843
844
	unsigned int active, want;
	bool running;
845
};
846
#endif
847

848
849
850
851
852
853
854
/**
 * 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
855
856
 * @SCAN_ONCHANNEL_SCANNING:  Do a software scan on only the current operating
 *	channel. This should not interrupt normal traffic.
857
858
859
860
 * @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.
861
 */
862
863
enum {
	SCAN_SW_SCANNING,
864
	SCAN_HW_SCANNING,
865
	SCAN_ONCHANNEL_SCANNING,
866
867
	SCAN_COMPLETED,
	SCAN_ABORTED,
868
869
870
871
872
873
874
875
876
877
};

/**
 * 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
878
879
880
 * @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
881
 * @SCAN_ABORT: Abort the scan and go back to operating channel
882
883
884
885
886
 */
enum mac80211_scan_state {
	SCAN_DECISION,
	SCAN_SET_CHANNEL,
	SCAN_SEND_PROBE,
887
888
	SCAN_SUSPEND,
	SCAN_RESUME,
889
	SCAN_ABORT,
890
891
};

892
893
894
895
896
897
898
899
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;

900
901
902
903
904
905
	/*
	 * private workqueue to mac80211. mac80211 makes this accessible
	 * via ieee80211_queue_work()
	 */
	struct workqueue_struct *workqueue;

906
	unsigned long queue_stop_reasons[IEEE80211_MAX_QUEUES];
907
	/* also used to protect ampdu_ac_queue and amdpu_ac_stop_refcnt */
908
	spinlock_t queue_stop_reason_lock;
909

910
	int open_count;
911
	int monitors, cooked_mntrs;
912
	/* number of interfaces with corresponding FIF_ flags */
913
914
915
	int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss, fif_pspoll,
	    fif_probe_req;
	int probe_req_reg;
916
	unsigned int filter_flags; /* FIF_* */
Johannes Berg's avatar
Johannes Berg committed
917

918
919
	bool wiphy_ciphers_allocated;

920
921
	bool use_chanctx;

Johannes Berg's avatar
Johannes Berg committed
922
923
924
	/* protects the aggregated multicast list and filter calls */
	spinlock_t filter_lock;

925
926
927
	/* used for uploading changed mc list */
	struct work_struct reconfig_filter;

Johannes Berg's avatar
Johannes Berg committed
928
	/* aggregated multicast list */
929
	struct netdev_hw_addr_list mc_list;
Johannes Berg's avatar
Johannes Berg committed
930

931
	bool tim_in_locked_section; /* see ieee80211_beacon_get() */
932
933
934
935
936
937
938
939
940

	/*
	 * 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
941
942
943
944
945
946
947
948
	/*
	 * 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;

949
950
951
952
953
954
	/*
	 * quiescing is true during the suspend process _only_ to
	 * ease timer cancelling etc.
	 */
	bool quiescing;

955
956
957
	/* device is started */
	bool started;

958
959
960
	/* device is during a HW reconfig */
	bool in_reconfig;

961
962
963
	/* wowlan is enabled -- don't reconfig on resume */
	bool wowlan;

964
965
966
	/* number of RX chains the hardware has */
	u8 rx_chains;

967
	int tx_headroom; /* required headroom for hardware/radiotap */
968
969
970
971
972
973
974
975
976
977

	/* Tasklet and skb queue to process calls from IRQ mode. All frames
	 * added to skb_queue will be processed, but frames in
	 * skb_queue_unreliable may be dropped if the total length of these
	 * queues increases over the limit. */
#define IEEE80211_IRQSAFE_QUEUE_LIMIT 128
	struct tasklet_struct tasklet;
	struct sk_buff_head skb_queue;
	struct sk_buff_head skb_queue_unreliable;

978
979
980
981
982
983
984
985
986
	/*
	 * Internal FIFO queue which is shared between multiple rx path
	 * stages. Its main task is to provide a serialization mechanism,
	 * so all rx handlers can enjoy having exclusive access to their
	 * private data structures.
	 */
	struct sk_buff_head rx_skb_queue;
	bool running_rx_handler;	/* protected by rx_skb_queue.lock */

987
988
	/* Station data */
	/*
989
990
	 * The mutex only protects the list, hash table and
	 * counter, reads are done with RCU.
991
	 */
992
	struct mutex sta_mtx;
993
	spinlock_t tim_lock;
994
	unsigned long num_sta;
995
	struct list_head sta_list;
996
	struct sta_info __rcu *sta_hash[STA_HASH_SIZE];
997
	struct timer_list sta_cleanup;
998
	int sta_generation;
999

1000
	struct sk_buff_head pending[IEEE80211_MAX_QUEUES];