ieee80211_i.h 48.5 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
	u32 device_ts;

91
	bool wmm_used;
92
	bool uapsd_supported;
93

94
95
96
97
#define IEEE80211_MAX_SUPP_RATES 32
	u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
	size_t supp_rates_len;

98
	/*
Lucas De Marchi's avatar
Lucas De Marchi committed
99
	 * During association, we save an ERP value from a probe response so
100
101
	 * that we can feed ERP info to the driver when handling the
	 * association completes. these fields probably won't be up-to-date
102
103
104
	 * otherwise, you probably don't want to use them.
	 */
	bool has_erp_value;
105
	u8 erp_value;
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
134
135
136
137
138
139
140
141

	/* 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
 * 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_WMM			= BIT(1),
	IEEE80211_BSS_VALID_RATES		= BIT(2),
	IEEE80211_BSS_VALID_ERP			= BIT(3)
142
143
};

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

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

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

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
struct beacon_data {
	u8 *head, *tail;
	int head_len, tail_len;
236
	struct rcu_head rcu_head;
237
238
};

239
240
241
242
243
244
struct probe_resp {
	struct rcu_head rcu_head;
	int len;
	u8 data[0];
};

245
struct ps_data {
246
247
	/* yes, this looks ugly, but guarantees that we can later use
	 * bitmap_empty :)
248
	 * NB: don't touch this bitmap, use sta_info_{set,clear}_tim_bit */
249
	u8 tim[sizeof(unsigned long) * BITS_TO_LONGS(IEEE80211_MAX_AID + 1)];
250
	struct sk_buff_head bc_buf;
251
	atomic_t num_sta_ps; /* number of stations in PS mode */
252
	int dtim_count;
253
	bool dtim_bc_mc;
254
255
};

256
257
258
259
260
261
262
263
264
265
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 */
};

266
267
struct ieee80211_if_wds {
	struct sta_info *sta;
268
	u8 remote_addr[ETH_ALEN];
269
270
271
};

struct ieee80211_if_vlan {
272
	struct list_head list;
273
274

	/* used for all tx if the VLAN is configured to 4-addr mode */
275
	struct sta_info __rcu *sta;
276
277
};

278
struct mesh_stats {
279
280
281
	__u32 fwded_mcast;		/* Mesh forwarded multicast frames */
	__u32 fwded_unicast;		/* Mesh forwarded unicast frames */
	__u32 fwded_frames;		/* Mesh total forwarded frames */
282
283
	__u32 dropped_frames_ttl;	/* Not transmitted since mesh_ttl == 0*/
	__u32 dropped_frames_no_route;	/* Not transmitted, no route found */
284
	__u32 dropped_frames_congestion;/* Not forwarded due to congestion */
285
286
287
288
289
290
291
292
293
294
};

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

295
296
297
298
299
#if HZ/100 == 0
#define IEEE80211_ROC_MIN_LEFT	1
#else
#define IEEE80211_ROC_MIN_LEFT	(HZ/100)
#endif
300

301
struct ieee80211_roc_work {
302
	struct list_head list;
303
	struct list_head dependents;
304

305
	struct delayed_work work;
306
307
308

	struct ieee80211_sub_if_data *sdata;

309
	struct ieee80211_channel *chan;
310

311
	bool started, abort, hw_begun, notified;
312

313
	unsigned long hw_start_time;
314

315
316
	u32 duration, req_duration;
	struct sk_buff *frame;
317
	u64 cookie, mgmt_tx_cookie;
318
319
};

320
/* flags used in struct ieee80211_if_managed.flags */
321
enum ieee80211_sta_flags {
322
323
324
	IEEE80211_STA_BEACON_POLL	= BIT(0),
	IEEE80211_STA_CONNECTION_POLL	= BIT(1),
	IEEE80211_STA_CONTROL_PORT	= BIT(2),
325
	IEEE80211_STA_DISABLE_HT	= BIT(4),
326
327
	IEEE80211_STA_CSA_RECEIVED	= BIT(5),
	IEEE80211_STA_MFP_ENABLED	= BIT(6),
328
	IEEE80211_STA_UAPSD_ENABLED	= BIT(7),
329
	IEEE80211_STA_NULLFUNC_ACKED	= BIT(8),
330
	IEEE80211_STA_RESET_SIGNAL_AVE	= BIT(9),
331
	IEEE80211_STA_DISABLE_40MHZ	= BIT(10),
332
	IEEE80211_STA_DISABLE_VHT	= BIT(11),
333
334
	IEEE80211_STA_DISABLE_80P80MHZ	= BIT(12),
	IEEE80211_STA_DISABLE_160MHZ	= BIT(13),
335
336
};

Johannes Berg's avatar
Johannes Berg committed
337
338
339
340
341
342
343
344
345
346
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;

347
348
349
	u16 sae_trans, sae_status;
	size_t data_len;
	u8 data[];
Johannes Berg's avatar
Johannes Berg committed
350
351
352
353
354
355
356
357
358
359
360
361
362
363
};

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;
364
	bool wmm, uapsd;
365
	bool have_beacon, need_beacon;
Johannes Berg's avatar
Johannes Berg committed
366
367
	bool synced;

368
369
	u8 ap_ht_param;

370
371
	struct ieee80211_vht_cap ap_vht_cap;

Johannes Berg's avatar
Johannes Berg committed
372
373
374
375
	size_t ie_len;
	u8 ie[];
};

376
struct ieee80211_if_managed {
377
	struct timer_list timer;
378
379
	struct timer_list conn_mon_timer;
	struct timer_list bcn_mon_timer;
Sujith's avatar
Sujith committed
380
	struct timer_list chswitch_timer;
381
	struct work_struct monitor_work;
Sujith's avatar
Sujith committed
382
	struct work_struct chswitch_work;
383
	struct work_struct beacon_connection_loss_work;
384
	struct work_struct csa_connection_drop_work;
385

386
	unsigned long beacon_timeout;
387
	unsigned long probe_timeout;
388
	int probe_send_count;
389
	bool nullfunc_failed;
390
	bool connection_loss;
391

392
	struct mutex mtx;
393
	struct cfg80211_bss *associated;
Johannes Berg's avatar
Johannes Berg committed
394
395
	struct ieee80211_mgd_auth_data *auth_data;
	struct ieee80211_mgd_assoc_data *assoc_data;
396

397
	u8 bssid[ETH_ALEN];
398

399
400
	u16 aid;

401
	unsigned long timers_running; /* used for quiesce/restart */
402
	bool powersave; /* powersave requested for this iface */
403
	bool broken_ap; /* AP is broken -- turn off powersave */
404
	u8 dtim_period;
405
	enum ieee80211_smps_mode req_smps, /* requested smps mode */
406
407
408
				 driver_smps_mode; /* smps mode request */

	struct work_struct request_smps_work;
409

410
	unsigned int flags;
411

412
	bool beacon_crc_valid;
413
414
	u32 beacon_crc;

415
416
417
418
	bool status_acked;
	bool status_received;
	__le16 status_fc;

419
420
421
422
423
424
	enum {
		IEEE80211_MFP_DISABLED,
		IEEE80211_MFP_OPTIONAL,
		IEEE80211_MFP_REQUIRED
	} mfp; /* management frame protection */

425
426
427
428
429
430
431
432
433
434
435
436
437
438
	/*
	 * 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;

439
	int wmm_last_param_set;
440
441

	u8 use_4addr;
442

443
444
	u8 p2p_noa_index;

445
446
447
448
449
450
451
452
453
454
455
	/* 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;

456
457
458
459
460
461
462
	/*
	 * 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;

463
464
465
466
467
468
	/*
	 * 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;
469
470
471
472
473
474
475
476

	/*
	 * 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;
477
478
479

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

482
483
484
struct ieee80211_if_ibss {
	struct timer_list timer;

Johannes Berg's avatar
Johannes Berg committed
485
486
	struct mutex mtx;

487
	unsigned long last_scan_completed;
488

489
490
	u32 basic_rates;

491
492
	bool timer_running;

493
494
	bool fixed_bssid;
	bool fixed_channel;
Johannes Berg's avatar
Johannes Berg committed
495
	bool privacy;
496

497
	bool control_port;
498
	unsigned int auth_frame_registrations;
499

500
	u8 bssid[ETH_ALEN] __aligned(2);
501
502
503
504
	u8 ssid[IEEE80211_MAX_SSID_LEN];
	u8 ssid_len, ie_len;
	u8 *ie;
	struct ieee80211_channel *channel;
505
	enum nl80211_channel_type channel_type;
506
507

	unsigned long ibss_join_req;
508
	/* probe response/beacon for IBSS */
509
510
	struct sk_buff __rcu *presp;
	struct sk_buff *skb;
511

512
513
514
	spinlock_t incomplete_lock;
	struct list_head incomplete_stations;

515
516
517
518
519
520
	enum {
		IEEE80211_IBSS_MLME_SEARCH,
		IEEE80211_IBSS_MLME_JOINED,
	} state;
};

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

539
540
541
struct ieee80211_if_mesh {
	struct timer_list housekeeping_timer;
	struct timer_list mesh_path_timer;
542
	struct timer_list mesh_path_root_timer;
543

544
545
	unsigned long timers_running;

546
	unsigned long wrkq_flags;
547
548
549
550

	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
551
	u8 mesh_pp_id;
552
	/* Active Path Selection Metric Identifier */
Rui Paulo's avatar
Rui Paulo committed
553
	u8 mesh_pm_id;
554
	/* Congestion Control Mode Identifier */
Rui Paulo's avatar
Rui Paulo committed
555
	u8 mesh_cc_id;
556
	/* Synchronization Protocol Identifier */
Rui Paulo's avatar
Rui Paulo committed
557
	u8 mesh_sp_id;
558
	/* Authentication Protocol Identifier */
Rui Paulo's avatar
Rui Paulo committed
559
	u8 mesh_auth_id;
560
561
	/* Local mesh Sequence Number */
	u32 sn;
562
563
564
	/* Last used PREQ ID */
	u32 preq_id;
	atomic_t mpaths;
565
566
	/* Timestamp of last SN update */
	unsigned long last_sn_update;
567
568
569
	/* Time when it's ok to send next PERR */
	unsigned long next_perr;
	/* Timestamp of last PREQ sent */
570
571
572
573
574
575
576
	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;
577
	atomic_t estab_plinks;
578
579
	u32 mesh_seqnum;
	bool accepting_plinks;
580
	int num_gates;
581
582
	const u8 *ie;
	u8 ie_len;
583
584
585
586
587
	enum {
		IEEE80211_MESH_SEC_NONE = 0x0,
		IEEE80211_MESH_SEC_AUTHED = 0x1,
		IEEE80211_MESH_SEC_SECURED = 0x2,
	} security;
588
	/* Extensible Synchronization Framework */
589
	const struct ieee80211_mesh_sync_ops *sync_ops;
590
591
592
	s64 sync_offset_clockdrift_max;
	spinlock_t sync_offset_lock;
	bool adjusting_tbtt;
593
594
595
596
597
	/* mesh power save */
	enum nl80211_mesh_power_mode nonpeer_pm;
	int ps_peers_light_sleep;
	int ps_peers_deep_sleep;
	struct ps_data ps;
598
};
Johannes Berg's avatar
Johannes Berg committed
599
600

#ifdef CONFIG_MAC80211_MESH
601
602
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name)	\
	do { (msh)->mshstats.name++; } while (0)
Johannes Berg's avatar
Johannes Berg committed
603
#else
604
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \
Johannes Berg's avatar
Johannes Berg committed
605
606
	do { } while (0)
#endif
607

608
609
610
611
612
613
614
615
616
/**
 * 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.
617
 * @IEEE80211_SDATA_DISCONNECT_RESUME: Disconnect after resume.
618
 * @IEEE80211_SDATA_IN_DRIVER: indicates interface was added to driver
619
620
621
622
 */
enum ieee80211_sub_if_data_flags {
	IEEE80211_SDATA_ALLMULTI		= BIT(0),
	IEEE80211_SDATA_PROMISC			= BIT(1),
623
624
	IEEE80211_SDATA_OPERATING_GMODE		= BIT(2),
	IEEE80211_SDATA_DONT_BRIDGE_PACKETS	= BIT(3),
625
	IEEE80211_SDATA_DISCONNECT_RESUME	= BIT(4),
626
	IEEE80211_SDATA_IN_DRIVER		= BIT(5),
627
628
};

629
630
631
632
633
/**
 * 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
634
635
 * @SDATA_STATE_OFFCHANNEL: This interface is currently in offchannel
 *	mode, so queues are stopped
636
637
 * @SDATA_STATE_OFFCHANNEL_BEACON_STOPPED: Beaconing was stopped due
 *	to offchannel, reset when offchannel returns
638
639
640
 */
enum ieee80211_sdata_state_bits {
	SDATA_STATE_RUNNING,
641
	SDATA_STATE_OFFCHANNEL,
642
	SDATA_STATE_OFFCHANNEL_BEACON_STOPPED,
643
644
};

645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
/**
 * 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;
665
	bool driver_present;
666
667
668
669

	struct ieee80211_chanctx_conf conf;
};

670
671
672
673
674
struct ieee80211_sub_if_data {
	struct list_head list;

	struct wireless_dev wdev;

675
676
677
	/* keys */
	struct list_head key_list;

678
679
680
	/* count for keys needing tailroom space allocation */
	int crypto_tx_tailroom_needed_cnt;

681
682
683
	struct net_device *dev;
	struct ieee80211_local *local;

684
	unsigned int flags;
685

686
687
	unsigned long state;

688
689
	int drop_unencrypted;

690
691
	char name[IFNAMSIZ];

692
693
694
	/* to detect idle changes */
	bool old_idle;

695
696
697
698
	/* Fragment table for host-based reassembly */
	struct ieee80211_fragment_entry	fragments[IEEE80211_FRAGMENT_MAX];
	unsigned int fragment_next;

699
700
701
	/* TID bitmap for NoAck policy */
	u16 noack_map;

702
703
704
	/* bit field of ACM bits (BIT(802.1D tag)) */
	u8 wmm_acm;

705
706
707
708
	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;
709

710
	u16 sequence_number;
711
712
	__be16 control_port_protocol;
	bool control_port_no_encrypt;
713

714
	struct ieee80211_tx_queue_params tx_conf[IEEE80211_NUM_ACS];
715

716
717
718
	/* used to reconfigure hardware SM PS */
	struct work_struct recalc_smps;

719
	struct work_struct work;
Johannes Berg's avatar
Johannes Berg committed
720
721
	struct sk_buff_head skb_queue;

722
723
724
	u8 needed_rx_chains;
	enum ieee80211_smps_mode smps_mode;

725
726
727
	int user_power_level; /* in dBm */
	int ap_power_level; /* in dBm */

728
	/*
729
730
731
	 * AP this belongs to: self in AP mode and
	 * corresponding AP in VLAN mode, NULL for
	 * all others (might be needed later in IBSS)
732
	 */
733
734
	struct ieee80211_if_ap *bss;

735
736
	/* bitmap of allowed (non-MCS) rate indexes for rate control */
	u32 rc_rateidx_mask[IEEE80211_NUM_BANDS];
737
	u8  rc_rateidx_mcs_mask[IEEE80211_NUM_BANDS][IEEE80211_HT_MCS_MASK_LEN];
738
739
740
741
742

	union {
		struct ieee80211_if_ap ap;
		struct ieee80211_if_wds wds;
		struct ieee80211_if_vlan vlan;
743
744
		struct ieee80211_if_managed mgd;
		struct ieee80211_if_ibss ibss;
745
		struct ieee80211_if_mesh mesh;
746
		u32 mntr_flags;
747
	} u;
748

749
750
751
752
	spinlock_t cleanup_stations_lock;
	struct list_head cleanup_stations;
	struct work_struct cleanup_stations_wk;

753
#ifdef CONFIG_MAC80211_DEBUGFS
754
	struct {
755
		struct dentry *dir;
756
		struct dentry *subdir_stations;
757
758
		struct dentry *default_unicast_key;
		struct dentry *default_multicast_key;
759
		struct dentry *default_mgmt_key;
760
	} debugfs;
761
#endif
762
763
764
765
766

#ifdef CONFIG_PM
	struct ieee80211_bss_conf suspend_bss_conf;
#endif

767
768
	/* must be last, dynamically sized area in this! */
	struct ieee80211_vif vif;
769
770
};

771
772
773
774
775
776
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
777
778
779
780
781
782
783
784
785
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))
786
		band = chanctx_conf->def.chan->band;
Johannes Berg's avatar
Johannes Berg committed
787
788
789
790
791
	rcu_read_unlock();

	return band;
}

792
793
794
795
796
797
enum sdata_queue_type {
	IEEE80211_SDATA_QUEUE_TYPE_FRAME	= 0,
	IEEE80211_SDATA_QUEUE_AGG_START		= 1,
	IEEE80211_SDATA_QUEUE_AGG_STOP		= 2,
};

798
799
800
enum {
	IEEE80211_RX_MSG	= 1,
	IEEE80211_TX_STATUS_MSG	= 2,
801
802
803
804
805
	IEEE80211_EOSP_MSG	= 3,
};

struct skb_eosp_msg_data {
	u8 sta[ETH_ALEN], iface[ETH_ALEN];
806
807
};

808
809
enum queue_stop_reason {
	IEEE80211_QUEUE_STOP_REASON_DRIVER,
810
	IEEE80211_QUEUE_STOP_REASON_PS,
811
812
	IEEE80211_QUEUE_STOP_REASON_CSA,
	IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
813
	IEEE80211_QUEUE_STOP_REASON_SUSPEND,
814
	IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
815
816
};

817
#ifdef CONFIG_MAC80211_LEDS
818
819
820
821
822
823
824
825
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;
826
827
	unsigned int active, want;
	bool running;
828
};
829
#endif
830

831
832
833
834
835
836
837
/**
 * 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
838
839
 * @SCAN_ONCHANNEL_SCANNING:  Do a software scan on only the current operating
 *	channel. This should not interrupt normal traffic.
840
841
842
843
 * @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.
844
 */
845
846
enum {
	SCAN_SW_SCANNING,
847
	SCAN_HW_SCANNING,
848
	SCAN_ONCHANNEL_SCANNING,
849
850
	SCAN_COMPLETED,
	SCAN_ABORTED,
851
852
853
854
855
856
857
858
859
860
};

/**
 * 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
861
862
863
 * @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
864
 * @SCAN_ABORT: Abort the scan and go back to operating channel
865
866
867
868
869
 */
enum mac80211_scan_state {
	SCAN_DECISION,
	SCAN_SET_CHANNEL,
	SCAN_SEND_PROBE,
870
871
	SCAN_SUSPEND,
	SCAN_RESUME,
872
	SCAN_ABORT,
873
874
};

875
876
877
878
879
880
881
882
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;

883
884
885
886
887
888
	/*
	 * private workqueue to mac80211. mac80211 makes this accessible
	 * via ieee80211_queue_work()
	 */
	struct workqueue_struct *workqueue;

889
	unsigned long queue_stop_reasons[IEEE80211_MAX_QUEUES];
890
	/* also used to protect ampdu_ac_queue and amdpu_ac_stop_refcnt */
891
	spinlock_t queue_stop_reason_lock;
892

893
	int open_count;
894
	int monitors, cooked_mntrs;
895
	/* number of interfaces with corresponding FIF_ flags */
896
897
898
	int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss, fif_pspoll,
	    fif_probe_req;
	int probe_req_reg;
899
	unsigned int filter_flags; /* FIF_* */
Johannes Berg's avatar
Johannes Berg committed
900

901
902
	bool wiphy_ciphers_allocated;

903
904
	bool use_chanctx;

Johannes Berg's avatar
Johannes Berg committed
905
906
907
	/* protects the aggregated multicast list and filter calls */
	spinlock_t filter_lock;

908
909
910
	/* used for uploading changed mc list */
	struct work_struct reconfig_filter;

Johannes Berg's avatar
Johannes Berg committed
911
	/* aggregated multicast list */
912
	struct netdev_hw_addr_list mc_list;
Johannes Berg's avatar
Johannes Berg committed
913

914
	bool tim_in_locked_section; /* see ieee80211_beacon_get() */
915
916
917
918
919
920
921
922
923

	/*
	 * 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
924
925
926
927
928
929
930
931
	/*
	 * 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;

932
933
934
935
936
937
	/*
	 * quiescing is true during the suspend process _only_ to
	 * ease timer cancelling etc.
	 */
	bool quiescing;

938
939
940
	/* device is started */
	bool started;

941
942
943
	/* device is during a HW reconfig */
	bool in_reconfig;

944
945
946
	/* wowlan is enabled -- don't reconfig on resume */
	bool wowlan;

947
948
949
	/* number of RX chains the hardware has */
	u8 rx_chains;

950
	int tx_headroom; /* required headroom for hardware/radiotap */
951
952
953
954
955
956
957
958
959
960

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

961
	spinlock_t rx_path_lock;
962

963
964
	/* Station data */
	/*
965
966
	 * The mutex only protects the list, hash table and
	 * counter, reads are done with RCU.
967
	 */
968
	struct mutex sta_mtx;
969
	spinlock_t tim_lock;
970
	unsigned long num_sta;
971
	struct list_head sta_list;
972
	struct sta_info __rcu *sta_hash[STA_HASH_SIZE];
973
	struct timer_list sta_cleanup;
974
	int sta_generation;
975

976
	struct sk_buff_head pending[IEEE80211_MAX_QUEUES];
977
978
	struct tasklet_struct tx_pending_tasklet;

979
	atomic_t agg_queue_stop[IEEE80211_MAX_QUEUES];
980

981
982
	/* number of interfaces with corresponding IFF_ flags */
	atomic_t iff_allmultis, iff_promiscs;
983
984
985

	struct rate_control_ref *rate_ctrl;

986
987
	struct crypto_cipher *wep_tx_tfm;
	struct crypto_cipher *wep_rx_tfm;
988
989
	u32 wep_iv;

990
	/* see iface.c */
991
	struct list_head interfaces;
992
	struct mutex iflist_mtx;
993

994
	/*
Johannes Berg's avatar
Johannes Berg committed
995
	 * Key mutex, protects sdata's key_list and sta_info's
996
997
	 * key pointers (write access, they're RCU.)
	 */
Johannes Berg's avatar
Johannes Berg committed
998
	struct mutex key_mtx;
999

1000
1001
	/* mutex for scan and work locking */
	struct mutex mtx;
1002

1003
	/* Scanning and BSS list */
1004
	unsigned long scanning;
1005
	struct cfg80211_ssid scan_ssid;
1006
	struct cfg80211_scan_request *int_scan_req;
1007
	struct cfg80211_scan_request *scan_req, *hw_scan_req;
1008
	struct ieee80211_channel *scan_channel;
1009
	enum ieee80211_band hw_scan_band;
1010
	int scan_channel_idx;
1011
	int scan_ies_len;
1012
	int hw_scan_ies_bufsize;
1013

1014
	struct work_struct sched_scan_stopped_work;
1015
	struct ieee80211_sub_if_data __rcu *sched_scan_sdata;
1016

1017
	unsigned long leave_oper_channel_time;
1018
	enum mac80211_scan_state next_scan_state;
1019
	struct delayed_work scan_work;
1020
	struct ieee80211_sub_if_data __rcu *scan_sdata;
Johannes Berg's avatar
Johannes Berg committed
1021
1022
1023
	struct ieee80211_channel *csa_channel;
	/* For backward compatibility only -- do not use */
	struct ieee80211_channel *_oper_channel;
1024
	enum nl80211_channel_type _oper_channel_type;
1025

1026
1027
1028
	/* Temporary remain-on-channel for off-channel operations */
	struct ieee80211_channel *tmp_channel;

1029
1030
1031
1032
	/* channel contexts */
	struct list_head chanctx_list;
	struct mutex chanctx_mtx;

1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
	/* SNMP counters */
	/* dot11CountersTable */
	u32 dot11TransmittedFragmentCount;
	u32 dot11MulticastTransmittedFrameCount;
	u32 dot11FailedCount;
	u32 dot11RetryCount;
	u32 dot11MultipleRetryCount;
	u32 dot11FrameDuplicateCount;
	u32 dot11ReceivedFragmentCount;
	u32 dot11MulticastReceivedFrameCount;
	u32 dot11TransmittedFrameCount;

#ifdef CONFIG_MAC80211_LEDS
	int tx_led_counter, rx_led_counter;
1047
	struct led_trigger *tx_led, *rx_led, *assoc_led, *radio_led;
1048
	struct tpt_led_trigger *tpt_led_trigger;
1049
1050
	char tx_led_name[32], rx_led_name[32],
	     assoc_led_name[32], radio_led_name[32];
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
#endif

#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
	/* TX/RX handler statistics */
	unsigned int tx_handlers_drop;
	unsigned int tx_handlers_queued;
	unsigned int tx_handlers_drop_unencrypted;
	unsigned int tx_handlers_drop_fragment;
	unsigned int tx_handlers_drop_wep;
	unsigned int tx_handlers_drop_not_assoc;
	unsigned int tx_handlers_drop_unauth_port;
	unsigned int rx_handlers_drop;
	unsigned int rx_handlers_queued;
	unsigned int rx_handlers_drop_nullfunc;
	unsigned int rx_handlers_drop_defrag;
	unsigned int rx_handlers_drop_short;
	unsigned int tx_expand_skb_head;
	unsigned int tx_expand_skb_head_cloned;
	unsigned int rx_expand_skb_head;
	unsigned int rx_expand_skb_head2;
	unsigned int rx_handlers_fragments;
	unsigned int tx_status_drop;
#define I802_DEBUG_INC(c) (c)++
#else /* CONFIG_MAC80211_DEBUG_COUNTERS */
#define I802_DEBUG_INC(c) do { } while (0)
#endif /* CONFIG_MAC80211_DEBUG_COUNTERS */


	int total_ps_buffered; /* total number of all buffered unicast and
				* multicast packets for power saving stations
				*/
1082

1083
	bool pspolling;
1084
	bool offchannel_ps_enabled;
1085
1086
1087
1088
1089
	/*
	 * PS can only be enabled when we have exactly one managed
	 * interface (and monitors) in PS, this then points there.
	 */
	struct ieee80211_sub_if_data *ps_sdata;
1090
1091
1092
	struct work_struct dynamic_ps_enable_work;
	struct work_struct dynamic_ps_disable_work;
	struct timer_list dynamic_ps_timer;
1093
	struct notifier_block network_latency_notifier;
1094
	struct notifier_block ifa_notifier;
1095
	struct notifier_block ifa6_notifier;
1096

1097
1098
1099
1100
1101
	/*
	 * The dynamic ps timeout configured from user space via WEXT -
	 * this will override whatever chosen by mac80211 internally.
	 */
	int dynamic_ps_forced_timeout;
1102
1103
	int dynamic_ps_user_timeout;
	bool disable_dynamic_ps;
1104

1105
	int user_power_level; /* in dBm, for all interfaces */
1106

1107
1108
	enum ieee80211_smps_mode smps_mode;

1109
1110
	struct work_struct restart_work;

1111
1112
#ifdef CONFIG_MAC80211_DEBUGFS
	struct local_debugfsdentries {
1113
		struct dentry *rcdir;
1114
1115
1116
		struct dentry *keys;
	} debugfs;
#endif
1117

1118
1119
1120
1121
	/*
	 * Remain-on-channel support
	 */
	struct list_head roc_list;
1122
	struct work_struct hw_roc_start, hw_roc_done;
1123
	unsigned long hw_roc_start_time;
1124
	u64 roc_cookie_counter;
1125

1126
1127
1128
	struct idr ack_status_frames;
	spinlock_t ack_status_lock;

1129
1130
	struct ieee80211_sub_if_data __rcu *p2p_sdata;

1131
1132
1133
1134
	/* dummy netdev for use w/ NAPI */
	struct net_device napi_dev;

	struct napi_struct napi;