ieee80211_i.h 49.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
	u32 device_ts_beacon, device_ts_presp;
90

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
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;
346
	bool timeout_started;
Johannes Berg's avatar
Johannes Berg committed
347

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

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

370
371
	u8 ap_ht_param;

372
373
	struct ieee80211_vht_cap ap_vht_cap;

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

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

388
	unsigned long beacon_timeout;
389
	unsigned long probe_timeout;
390
	int probe_send_count;
391
	bool nullfunc_failed;
392
	bool connection_loss;
393

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

399
	u8 bssid[ETH_ALEN];
400

401
402
	u16 aid;

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

	struct work_struct request_smps_work;
411

412
	unsigned int flags;
413

414
	bool beacon_crc_valid;
415
416
	u32 beacon_crc;

417
418
419
420
	bool status_acked;
	bool status_received;
	__le16 status_fc;

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

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

441
	int wmm_last_param_set;
442
443

	u8 use_4addr;
444

445
446
	u8 p2p_noa_index;

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

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

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

	/*
	 * 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;
479
480
481

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

484
485
486
struct ieee80211_if_ibss {
	struct timer_list timer;

Johannes Berg's avatar
Johannes Berg committed
487
488
	struct mutex mtx;

489
	unsigned long last_scan_completed;
490

491
492
	u32 basic_rates;

493
494
	bool timer_running;

495
496
	bool fixed_bssid;
	bool fixed_channel;
Johannes Berg's avatar
Johannes Berg committed
497
	bool privacy;
498

499
	bool control_port;
500
	unsigned int auth_frame_registrations;
501

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

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

514
515
516
	spinlock_t incomplete_lock;
	struct list_head incomplete_stations;

517
518
519
520
521
522
	enum {
		IEEE80211_IBSS_MLME_SEARCH,
		IEEE80211_IBSS_MLME_JOINED,
	} state;
};

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

541
542
543
struct ieee80211_if_mesh {
	struct timer_list housekeeping_timer;
	struct timer_list mesh_path_timer;
544
	struct timer_list mesh_path_root_timer;
545

546
547
	unsigned long timers_running;

548
	unsigned long wrkq_flags;
549
550
551
552

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

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

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

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

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

	struct ieee80211_chanctx_conf conf;
};

672
673
674
675
676
struct ieee80211_sub_if_data {
	struct list_head list;

	struct wireless_dev wdev;

677
678
679
	/* keys */
	struct list_head key_list;

680
681
682
	/* count for keys needing tailroom space allocation */
	int crypto_tx_tailroom_needed_cnt;

683
684
685
	struct net_device *dev;
	struct ieee80211_local *local;

686
	unsigned int flags;
687

688
689
	unsigned long state;

690
691
	int drop_unencrypted;

692
693
	char name[IFNAMSIZ];

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

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

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

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

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

713
	struct ieee80211_tx_queue_params tx_conf[IEEE80211_NUM_ACS];
714

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

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

721
722
723
	u8 needed_rx_chains;
	enum ieee80211_smps_mode smps_mode;

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

727
728
729
	bool radar_required;
	struct delayed_work dfs_cac_timer_work;

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

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

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

751
752
753
754
	spinlock_t cleanup_stations_lock;
	struct list_head cleanup_stations;
	struct work_struct cleanup_stations_wk;

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

#ifdef CONFIG_PM
	struct ieee80211_bss_conf suspend_bss_conf;
#endif

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

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

	return band;
}

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

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

struct skb_eosp_msg_data {
	u8 sta[ETH_ALEN], iface[ETH_ALEN];
808
809
};

810
811
enum queue_stop_reason {
	IEEE80211_QUEUE_STOP_REASON_DRIVER,
812
	IEEE80211_QUEUE_STOP_REASON_PS,
813
814
	IEEE80211_QUEUE_STOP_REASON_CSA,
	IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
815
	IEEE80211_QUEUE_STOP_REASON_SUSPEND,
816
	IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
817
	IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL,
818
819
};

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

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

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

878
879
880
881
882
883
884
885
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;

886
887
888
889
890
891
	/*
	 * private workqueue to mac80211. mac80211 makes this accessible
	 * via ieee80211_queue_work()
	 */
	struct workqueue_struct *workqueue;

892
	unsigned long queue_stop_reasons[IEEE80211_MAX_QUEUES];
893
	/* also used to protect ampdu_ac_queue and amdpu_ac_stop_refcnt */
894
	spinlock_t queue_stop_reason_lock;
895

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

904
905
	bool wiphy_ciphers_allocated;

906
907
	bool use_chanctx;

Johannes Berg's avatar
Johannes Berg committed
908
909
910
	/* protects the aggregated multicast list and filter calls */
	spinlock_t filter_lock;

911
912
913
	/* used for uploading changed mc list */
	struct work_struct reconfig_filter;

Johannes Berg's avatar
Johannes Berg committed
914
	/* aggregated multicast list */
915
	struct netdev_hw_addr_list mc_list;
Johannes Berg's avatar
Johannes Berg committed
916

917
	bool tim_in_locked_section; /* see ieee80211_beacon_get() */
918
919
920
921
922
923
924
925
926

	/*
	 * 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
927
928
929
930
931
932
933
934
	/*
	 * 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;

935
936
937
938
939
940
	/*
	 * quiescing is true during the suspend process _only_ to
	 * ease timer cancelling etc.
	 */
	bool quiescing;

941
942
943
	/* device is started */
	bool started;

944
945
946
	/* device is during a HW reconfig */
	bool in_reconfig;

947
948
949
	/* wowlan is enabled -- don't reconfig on resume */
	bool wowlan;

950
951
952
953
	/* DFS/radar detection is enabled */
	bool radar_detect_enabled;
	struct work_struct radar_detected_work;

954
955
956
	/* number of RX chains the hardware has */
	u8 rx_chains;

957
	int tx_headroom; /* required headroom for hardware/radiotap */
958
959
960
961
962
963
964
965
966
967

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

968
	spinlock_t rx_path_lock;
969

970
971
	/* Station data */
	/*
972
973
	 * The mutex only protects the list, hash table and
	 * counter, reads are done with RCU.
974
	 */
975
	struct mutex sta_mtx;
976
	spinlock_t tim_lock;
977
	unsigned long num_sta;
978
	struct list_head sta_list;
979
	struct sta_info __rcu *sta_hash[STA_HASH_SIZE];
980
	struct timer_list sta_cleanup;
981
	int sta_generation;
982

983
	struct sk_buff_head pending[IEEE80211_MAX_QUEUES];
984
985
	struct tasklet_struct tx_pending_tasklet;

986
	atomic_t agg_queue_stop[IEEE80211_MAX_QUEUES];
987

988
989
	/* number of interfaces with corresponding IFF_ flags */
	atomic_t iff_allmultis, iff_promiscs;
990
991
992

	struct rate_control_ref *rate_ctrl;

993
994
	struct crypto_cipher *wep_tx_tfm;
	struct crypto_cipher *wep_rx_tfm;
995
996
	u32 wep_iv;

997
	/* see iface.c */
998
	struct list_head interfaces;
999
	struct mutex iflist_mtx;
1000

1001
	/*
Johannes Berg's avatar
Johannes Berg committed
1002
	 * Key mutex, protects sdata's key_list and sta_info's
1003
1004
	 * key pointers (write access, they're RCU.)
	 */
Johannes Berg's avatar
Johannes Berg committed
1005
	struct mutex key_mtx;
1006

1007
1008
	/* mutex for scan and work locking */
	struct mutex mtx;
1009

1010
	/* Scanning and BSS list */
1011
	unsigned long scanning;
1012
	struct cfg80211_ssid scan_ssid;
1013
	struct cfg80211_scan_request *int_scan_req;
1014
	struct cfg80211_scan_request *scan_req, *hw_scan_req;
1015
	struct ieee80211_channel *scan_channel;
1016
	enum ieee80211_band hw_scan_band;
1017
	int scan_channel_idx;
1018
	int scan_ies_len;
1019
	int hw_scan_ies_bufsize;
1020

1021
	struct work_struct sched_scan_stopped_work;
1022
	struct ieee80211_sub_if_data __rcu *sched_scan_sdata;
1023

1024
	unsigned long leave_oper_channel_time;
1025
	enum mac80211_scan_state next_scan_state;
1026
	struct delayed_work scan_work;
1027
	struct ieee80211_sub_if_data __rcu *scan_sdata;
Johannes Berg's avatar
Johannes Berg committed
1028
1029
1030
	struct ieee80211_channel *csa_channel;
	/* For backward compatibility only -- do not use */
	struct ieee80211_channel *_oper_channel;
1031
	enum nl80211_channel_type _oper_channel_type;
1032

1033
1034
1035
	/* Temporary remain-on-channel for off-channel operations */
	struct ieee80211_channel *tmp_channel;

1036
1037
1038
1039
	/* channel contexts */
	struct list_head chanctx_list;
	struct mutex chanctx_mtx;

1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
	/* 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;
1054
	struct led_trigger *tx_led, *rx_led, *assoc_led, *radio_led;
1055
	struct tpt_led_trigger *tpt_led_trigger;
1056
1057
	char tx_led_name[32], rx_led_name[32],
	     assoc_led_name[32], radio_led_name[32];
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
#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
				*/
1089

1090
	bool pspolling;
1091
	bool offchannel_ps_enabled;
1092
1093
1094
1095
1096
	/*
	 * 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;
1097
1098
1099
	struct work_struct dynamic_ps_enable_work;
	struct work_struct dynamic_ps_disable_work;
	struct timer_list dynamic_ps_timer;
1100
	struct notifier_block network_latency_notifier;
1101
	struct notifier_block ifa_notifier;
1102
	struct notifier_block ifa6_notifier;
1103

1104
1105
1106
1107
1108
1109
	/*
	 * The dynamic ps timeout configured from user space via WEXT -
	 * this will override whatever chosen by mac80211 internally.
	 */
	int dynamic_ps_forced_timeout;

1110
	int user_power_level; /* in dBm, for all interfaces */
1111

1112
1113
	enum ieee80211_smps_mode smps_mode;

1114
1115
	struct work_struct restart_work;

1116
1117
#ifdef CONFIG_MAC80211_DEBUGFS
	struct local_debugfsdentries {
1118
		struct dentry *rcdir;
1119
1120
1121
		struct dentry *keys;
	} debugfs;
#endif
1122

1123
1124
1125
1126
	/*
	 * Remain-on-channel support
	 */
	struct list_head roc_list;
1127
	struct work_struct hw_roc_start, hw_roc_done;
1128
	unsigned long hw_roc_start_time;
1129
	u64 roc_cookie_counter;