ieee80211_i.h 44.4 KB
Newer Older
1
2
3
4
/*
 * Copyright 2002-2005, Instant802 Networks, Inc.
 * Copyright 2005, Devicescape Software, Inc.
 * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
5
 * Copyright 2007-2010	Johannes Berg <johannes@sipsolutions.net>
6
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
33
#include "sta_info.h"

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

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

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

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

58
59
60
61
62
63
64
65
66
#define IEEE80211_DEFAULT_UAPSD_QUEUES \
	(IEEE80211_WMM_IE_STA_QOSINFO_AC_BK |	\
	 IEEE80211_WMM_IE_STA_QOSINFO_AC_BE |	\
	 IEEE80211_WMM_IE_STA_QOSINFO_AC_VI |	\
	 IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)

#define IEEE80211_DEFAULT_MAX_SP_LEN		\
	IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL

67
68
69
70
71
72
73
74
75
76
77
78
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 */
};


79
struct ieee80211_bss {
80
81
	/* don't want to look up all the time */
	size_t ssid_len;
82
	u8 ssid[IEEE80211_MAX_SSID_LEN];
83

84
	u8 dtim_period;
85

86
	bool wmm_used;
87
	bool uapsd_supported;
88
89
90

	unsigned long last_probe_resp;

91
92
93
#ifdef CONFIG_MAC80211_MESH
	u8 *mesh_id;
	size_t mesh_id_len;
94
	u8 *mesh_cfg;
Johannes Berg's avatar
Johannes Berg committed
95
#endif
96

97
98
99
100
#define IEEE80211_MAX_SUPP_RATES 32
	u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
	size_t supp_rates_len;

101
	/*
Lucas De Marchi's avatar
Lucas De Marchi committed
102
	 * During association, we save an ERP value from a probe response so
103
104
	 * that we can feed ERP info to the driver when handling the
	 * association completes. these fields probably won't be up-to-date
105
106
107
	 * otherwise, you probably don't want to use them.
	 */
	bool has_erp_value;
108
	u8 erp_value;
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
142
143
144
145
146

	/* 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)
147
148
};

149
static inline u8 *bss_mesh_cfg(struct ieee80211_bss *bss)
Johannes Berg's avatar
Johannes Berg committed
150
151
152
153
154
155
156
{
#ifdef CONFIG_MAC80211_MESH
	return bss->mesh_cfg;
#endif
	return NULL;
}

157
static inline u8 *bss_mesh_id(struct ieee80211_bss *bss)
Johannes Berg's avatar
Johannes Berg committed
158
159
160
161
162
163
164
{
#ifdef CONFIG_MAC80211_MESH
	return bss->mesh_id;
#endif
	return NULL;
}

165
static inline u8 bss_mesh_id_len(struct ieee80211_bss *bss)
Johannes Berg's avatar
Johannes Berg committed
166
167
168
169
170
171
172
{
#ifdef CONFIG_MAC80211_MESH
	return bss->mesh_id_len;
#endif
	return 0;
}

173

174
175
176
177
178
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)

179
180
181
182
183
#define IEEE80211_TX_UNICAST		BIT(1)
#define IEEE80211_TX_PS_BUFFERED	BIT(2)

struct ieee80211_tx_data {
	struct sk_buff *skb;
184
	struct sk_buff_head skbs;
185
186
187
188
189
190
191
	struct ieee80211_local *local;
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;
	struct ieee80211_key *key;

	struct ieee80211_channel *channel;

192
	unsigned int flags;
193
194
195
};


196
typedef unsigned __bitwise__ ieee80211_rx_result;
Johannes Berg's avatar
Johannes Berg committed
197
198
199
200
#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)
201

202
203
204
205
206
207
208
209
/**
 * enum ieee80211_packet_rx_flags - packet RX flags
 * @IEEE80211_RX_RA_MATCH: frame is destined to interface currently processed
 *	(incl. multicast frames)
 * @IEEE80211_RX_IN_SCAN: received while scanning
 * @IEEE80211_RX_FRAGMENTED: fragmented frame
 * @IEEE80211_RX_AMSDU: a-MSDU packet
 * @IEEE80211_RX_MALFORMED_ACTION_FRM: action frame is malformed
210
 * @IEEE80211_RX_DEFERRED_RELEASE: frame was subjected to receive reordering
211
212
213
214
215
216
217
218
219
220
 *
 * 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_IN_SCAN			= BIT(0),
	IEEE80211_RX_RA_MATCH			= BIT(1),
	IEEE80211_RX_FRAGMENTED			= BIT(2),
	IEEE80211_RX_AMSDU			= BIT(3),
	IEEE80211_RX_MALFORMED_ACTION_FRM	= BIT(4),
221
	IEEE80211_RX_DEFERRED_RELEASE		= BIT(5),
222
223
224
225
226
227
};

/**
 * enum ieee80211_rx_flags - RX data flags
 *
 * @IEEE80211_RX_CMNTR: received on cooked monitor already
Johannes Berg's avatar
Johannes Berg committed
228
229
 * @IEEE80211_RX_BEACON_REPORTED: This frame was already reported
 *	to cfg80211_report_obss_beacon().
230
231
232
233
234
235
 *
 * 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
236
	IEEE80211_RX_BEACON_REPORTED	= BIT(1),
237
};
238
239

struct ieee80211_rx_data {
240
241
242
243
244
	struct sk_buff *skb;
	struct ieee80211_local *local;
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;
	struct ieee80211_key *key;
245
246

	unsigned int flags;
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262

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

263
264
	u32 tkip_iv32;
	u16 tkip_iv16;
265
266
};

267
268
269
struct beacon_data {
	u8 *head, *tail;
	int head_len, tail_len;
270
	struct rcu_head rcu_head;
271
272
};

273
struct ieee80211_if_ap {
274
	struct beacon_data __rcu *beacon;
275
	struct sk_buff __rcu *probe_resp;
276

277
278
	struct list_head vlans;

279
280
	/* yes, this looks ugly, but guarantees that we can later use
	 * bitmap_empty :)
281
	 * NB: don't touch this bitmap, use sta_info_{set,clear}_tim_bit */
282
283
	u8 tim[sizeof(unsigned long) * BITS_TO_LONGS(IEEE80211_MAX_AID + 1)];
	struct sk_buff_head ps_bc_buf;
284
	atomic_t num_sta_ps; /* number of stations in PS mode */
285
	atomic_t num_sta_authorized; /* number of authorized stations */
286
	int dtim_count;
287
	bool dtim_bc_mc;
288
289
290
291
};

struct ieee80211_if_wds {
	struct sta_info *sta;
292
	u8 remote_addr[ETH_ALEN];
293
294
295
};

struct ieee80211_if_vlan {
296
	struct list_head list;
297
298

	/* used for all tx if the VLAN is configured to 4-addr mode */
299
	struct sta_info __rcu *sta;
300
301
};

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

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

320
enum ieee80211_work_type {
321
322
	IEEE80211_WORK_ABORT,
	IEEE80211_WORK_REMAIN_ON_CHANNEL,
323
	IEEE80211_WORK_OFFCHANNEL_TX,
324
325
};

326
327
328
329
330
331
332
333
334
335
336
337
/**
 * enum work_done_result - indicates what to do after work was done
 *
 * @WORK_DONE_DESTROY: This work item is no longer needed, destroy.
 * @WORK_DONE_REQUEUE: This work item was reset to be reused, and
 *	should be requeued.
 */
enum work_done_result {
	WORK_DONE_DESTROY,
	WORK_DONE_REQUEUE,
};

338
struct ieee80211_work {
339
340
	struct list_head list;

341
342
343
344
345
346
347
	struct rcu_head rcu_head;

	struct ieee80211_sub_if_data *sdata;

	enum work_done_result (*done)(struct ieee80211_work *wk,
				      struct sk_buff *skb);

348
	struct ieee80211_channel *chan;
349
	enum nl80211_channel_type chan_type;
350

351
352
353
	unsigned long timeout;
	enum ieee80211_work_type type;

354
355
	bool started;

356
	union {
357
		struct {
358
			u32 duration;
359
		} remain;
360
361
362
		struct {
			struct sk_buff *frame;
			u32 wait;
363
			bool status;
364
		} offchan_tx;
365
	};
Johannes Berg's avatar
Johannes Berg committed
366

Johannes Berg's avatar
Johannes Berg committed
367
368
	size_t data_len;
	u8 data[];
369
370
};

371
/* flags used in struct ieee80211_if_managed.flags */
372
enum ieee80211_sta_flags {
373
374
375
376
377
378
	IEEE80211_STA_BEACON_POLL	= BIT(0),
	IEEE80211_STA_CONNECTION_POLL	= BIT(1),
	IEEE80211_STA_CONTROL_PORT	= BIT(2),
	IEEE80211_STA_DISABLE_11N	= BIT(4),
	IEEE80211_STA_CSA_RECEIVED	= BIT(5),
	IEEE80211_STA_MFP_ENABLED	= BIT(6),
379
	IEEE80211_STA_UAPSD_ENABLED	= BIT(7),
380
	IEEE80211_STA_NULLFUNC_ACKED	= BIT(8),
381
	IEEE80211_STA_RESET_SIGNAL_AVE	= BIT(9),
382
	IEEE80211_STA_DISABLE_40MHZ	= BIT(10),
383
384
};

Johannes Berg's avatar
Johannes Berg committed
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
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;

	size_t ie_len;
	u8 ie[];
};

struct ieee80211_mgd_assoc_data {
	struct cfg80211_bss *bss;
	const u8 *supp_rates;
402
	const u8 *ht_operation_ie;
Johannes Berg's avatar
Johannes Berg committed
403
404
405
406
407
408
409
410
411

	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;
412
	bool wmm, uapsd;
Johannes Berg's avatar
Johannes Berg committed
413
414
415
416
417
418
419
420
	bool have_beacon;
	bool sent_assoc;
	bool synced;

	size_t ie_len;
	u8 ie[];
};

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

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

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

440
	u8 bssid[ETH_ALEN];
441

442
443
	u16 aid;

444
	unsigned long timers_running; /* used for quiesce/restart */
445
	bool powersave; /* powersave requested for this iface */
446
	bool broken_ap; /* AP is broken -- turn off powersave */
447
	enum ieee80211_smps_mode req_smps, /* requested smps mode */
448
449
450
451
				 ap_smps, /* smps mode AP thinks we're in */
				 driver_smps_mode; /* smps mode request */

	struct work_struct request_smps_work;
452

453
	unsigned int flags;
454

455
	bool beacon_crc_valid;
456
457
	u32 beacon_crc;

458
459
460
461
462
463
	enum {
		IEEE80211_MFP_DISABLED,
		IEEE80211_MFP_OPTIONAL,
		IEEE80211_MFP_REQUIRED
	} mfp; /* management frame protection */

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

478
	int wmm_last_param_set;
479
480

	u8 use_4addr;
481
482
483
484
485
486
487
488
489
490
491
492

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

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

500
501
502
503
504
505
	/*
	 * 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;
506
507
508
509
510
511
512
513

	/*
	 * 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;
514
515
516

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

519
520
521
struct ieee80211_if_ibss {
	struct timer_list timer;

Johannes Berg's avatar
Johannes Berg committed
522
523
	struct mutex mtx;

524
	unsigned long last_scan_completed;
525

526
527
	u32 basic_rates;

528
529
	bool timer_running;

530
531
	bool fixed_bssid;
	bool fixed_channel;
Johannes Berg's avatar
Johannes Berg committed
532
	bool privacy;
533

534
535
	bool control_port;

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

	unsigned long ibss_join_req;
544
	/* probe response/beacon for IBSS */
545
546
	struct sk_buff __rcu *presp;
	struct sk_buff *skb;
547

548
549
550
	spinlock_t incomplete_lock;
	struct list_head incomplete_stations;

551
552
553
554
555
556
	enum {
		IEEE80211_IBSS_MLME_SEARCH,
		IEEE80211_IBSS_MLME_JOINED,
	} state;
};

557
558
559
struct ieee80211_if_mesh {
	struct timer_list housekeeping_timer;
	struct timer_list mesh_path_timer;
560
	struct timer_list mesh_path_root_timer;
561

562
563
	unsigned long timers_running;

564
	unsigned long wrkq_flags;
565
566
567
568

	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
569
	u8 mesh_pp_id;
570
	/* Active Path Selection Metric Identifier */
Rui Paulo's avatar
Rui Paulo committed
571
	u8 mesh_pm_id;
572
	/* Congestion Control Mode Identifier */
Rui Paulo's avatar
Rui Paulo committed
573
	u8 mesh_cc_id;
574
	/* Synchronization Protocol Identifier */
Rui Paulo's avatar
Rui Paulo committed
575
	u8 mesh_sp_id;
576
	/* Authentication Protocol Identifier */
Rui Paulo's avatar
Rui Paulo committed
577
	u8 mesh_auth_id;
578
579
	/* Local mesh Sequence Number */
	u32 sn;
580
581
582
	/* Last used PREQ ID */
	u32 preq_id;
	atomic_t mpaths;
583
584
	/* Timestamp of last SN update */
	unsigned long last_sn_update;
585
586
587
	/* Time when it's ok to send next PERR */
	unsigned long next_perr;
	/* Timestamp of last PREQ sent */
588
589
590
591
592
593
594
595
596
	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;
	u32 mesh_seqnum;
	bool accepting_plinks;
597
	int num_gates;
598
599
	const u8 *ie;
	u8 ie_len;
600
601
602
603
604
	enum {
		IEEE80211_MESH_SEC_NONE = 0x0,
		IEEE80211_MESH_SEC_AUTHED = 0x1,
		IEEE80211_MESH_SEC_SECURED = 0x2,
	} security;
605
};
Johannes Berg's avatar
Johannes Berg committed
606
607

#ifdef CONFIG_MAC80211_MESH
608
609
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name)	\
	do { (msh)->mshstats.name++; } while (0)
Johannes Berg's avatar
Johannes Berg committed
610
#else
611
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \
Johannes Berg's avatar
Johannes Berg committed
612
613
	do { } while (0)
#endif
614

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

636
637
638
639
640
/**
 * 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
641
642
 * @SDATA_STATE_OFFCHANNEL: This interface is currently in offchannel
 *	mode, so queues are stopped
643
644
645
 */
enum ieee80211_sdata_state_bits {
	SDATA_STATE_RUNNING,
646
	SDATA_STATE_OFFCHANNEL,
647
648
};

649
650
651
652
653
struct ieee80211_sub_if_data {
	struct list_head list;

	struct wireless_dev wdev;

654
655
656
	/* keys */
	struct list_head key_list;

657
658
659
	/* count for keys needing tailroom space allocation */
	int crypto_tx_tailroom_needed_cnt;

660
661
662
	struct net_device *dev;
	struct ieee80211_local *local;

663
	unsigned int flags;
664

665
666
	unsigned long state;

667
668
	int drop_unencrypted;

669
670
	char name[IFNAMSIZ];

671
672
673
	/* to detect idle changes */
	bool old_idle;

674
675
676
677
	/* Fragment table for host-based reassembly */
	struct ieee80211_fragment_entry	fragments[IEEE80211_FRAGMENT_MAX];
	unsigned int fragment_next;

678
679
680
	/* TID bitmap for NoAck policy */
	u16 noack_map;

681
682
683
684
	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;
685

686
	u16 sequence_number;
687
688
	__be16 control_port_protocol;
	bool control_port_no_encrypt;
689

690
691
	struct ieee80211_tx_queue_params tx_conf[IEEE80211_MAX_QUEUES];

692
	struct work_struct work;
Johannes Berg's avatar
Johannes Berg committed
693
694
	struct sk_buff_head skb_queue;

695
696
	bool arp_filter_state;

697
	/*
698
699
700
	 * AP this belongs to: self in AP mode and
	 * corresponding AP in VLAN mode, NULL for
	 * all others (might be needed later in IBSS)
701
	 */
702
703
	struct ieee80211_if_ap *bss;

704
705
	/* bitmap of allowed (non-MCS) rate indexes for rate control */
	u32 rc_rateidx_mask[IEEE80211_NUM_BANDS];
706
	u8  rc_rateidx_mcs_mask[IEEE80211_NUM_BANDS][IEEE80211_HT_MCS_MASK_LEN];
707
708
709
710
711

	union {
		struct ieee80211_if_ap ap;
		struct ieee80211_if_wds wds;
		struct ieee80211_if_vlan vlan;
712
713
		struct ieee80211_if_managed mgd;
		struct ieee80211_if_ibss ibss;
714
		struct ieee80211_if_mesh mesh;
715
		u32 mntr_flags;
716
	} u;
717
718

#ifdef CONFIG_MAC80211_DEBUGFS
719
	struct {
720
		struct dentry *dir;
721
		struct dentry *subdir_stations;
722
723
		struct dentry *default_unicast_key;
		struct dentry *default_multicast_key;
724
		struct dentry *default_mgmt_key;
725
	} debugfs;
726
#endif
727
728
	/* must be last, dynamically sized area in this! */
	struct ieee80211_vif vif;
729
730
};

731
732
733
734
735
736
static inline
struct ieee80211_sub_if_data *vif_to_sdata(struct ieee80211_vif *p)
{
	return container_of(p, struct ieee80211_sub_if_data, vif);
}

737
738
739
740
741
742
enum sdata_queue_type {
	IEEE80211_SDATA_QUEUE_TYPE_FRAME	= 0,
	IEEE80211_SDATA_QUEUE_AGG_START		= 1,
	IEEE80211_SDATA_QUEUE_AGG_STOP		= 2,
};

743
744
745
enum {
	IEEE80211_RX_MSG	= 1,
	IEEE80211_TX_STATUS_MSG	= 2,
746
747
748
749
750
	IEEE80211_EOSP_MSG	= 3,
};

struct skb_eosp_msg_data {
	u8 sta[ETH_ALEN], iface[ETH_ALEN];
751
752
};

753
754
enum queue_stop_reason {
	IEEE80211_QUEUE_STOP_REASON_DRIVER,
755
	IEEE80211_QUEUE_STOP_REASON_PS,
756
757
	IEEE80211_QUEUE_STOP_REASON_CSA,
	IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
758
	IEEE80211_QUEUE_STOP_REASON_SUSPEND,
759
	IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
760
761
};

762
#ifdef CONFIG_MAC80211_LEDS
763
764
765
766
767
768
769
770
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;
771
772
	unsigned int active, want;
	bool running;
773
};
774
#endif
775

776
777
778
779
780
781
782
/**
 * 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
783
784
785
786
 * @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.
787
 */
788
789
enum {
	SCAN_SW_SCANNING,
790
	SCAN_HW_SCANNING,
791
792
	SCAN_COMPLETED,
	SCAN_ABORTED,
793
794
795
796
797
798
799
800
801
802
};

/**
 * 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
803
804
805
 * @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
806
807
808
809
810
 */
enum mac80211_scan_state {
	SCAN_DECISION,
	SCAN_SET_CHANNEL,
	SCAN_SEND_PROBE,
811
812
	SCAN_SUSPEND,
	SCAN_RESUME,
813
814
};

815
816
817
818
819
820
821
822
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;

823
824
825
826
827
828
829
	/*
	 * work stuff, potentially off-channel (in the future)
	 */
	struct list_head work_list;
	struct timer_list work_timer;
	struct work_struct work_work;

830
831
832
833
834
835
	/*
	 * private workqueue to mac80211. mac80211 makes this accessible
	 * via ieee80211_queue_work()
	 */
	struct workqueue_struct *workqueue;

836
	unsigned long queue_stop_reasons[IEEE80211_MAX_QUEUES];
837
	/* also used to protect ampdu_ac_queue and amdpu_ac_stop_refcnt */
838
	spinlock_t queue_stop_reason_lock;
839

840
	int open_count;
841
	int monitors, cooked_mntrs;
842
	/* number of interfaces with corresponding FIF_ flags */
843
844
845
	int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss, fif_pspoll,
	    fif_probe_req;
	int probe_req_reg;
846
	unsigned int filter_flags; /* FIF_* */
Johannes Berg's avatar
Johannes Berg committed
847

848
849
	bool wiphy_ciphers_allocated;

Johannes Berg's avatar
Johannes Berg committed
850
851
852
	/* protects the aggregated multicast list and filter calls */
	spinlock_t filter_lock;

853
854
855
	/* used for uploading changed mc list */
	struct work_struct reconfig_filter;

856
857
858
	/* used to reconfigure hardware SM PS */
	struct work_struct recalc_smps;

Johannes Berg's avatar
Johannes Berg committed
859
	/* aggregated multicast list */
860
	struct netdev_hw_addr_list mc_list;
Johannes Berg's avatar
Johannes Berg committed
861

862
	bool tim_in_locked_section; /* see ieee80211_beacon_get() */
863
864
865
866
867
868
869
870
871

	/*
	 * 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
872
873
874
875
876
877
878
879
	/*
	 * 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;

880
881
882
883
884
885
	/*
	 * quiescing is true during the suspend process _only_ to
	 * ease timer cancelling etc.
	 */
	bool quiescing;

886
887
888
	/* device is started */
	bool started;

889
890
891
	/* wowlan is enabled -- don't reconfig on resume */
	bool wowlan;

892
	int tx_headroom; /* required headroom for hardware/radiotap */
893
894
895
896
897
898
899
900
901
902

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

903
904
905
906
907
908
909
910
911
	/*
	 * 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 */

912
913
	/* Station data */
	/*
914
915
	 * The mutex only protects the list, hash table and
	 * counter, reads are done with RCU.
916
	 */
917
	struct mutex sta_mtx;
918
	spinlock_t tim_lock;
919
	unsigned long num_sta;
920
	struct list_head sta_list;
921
	struct sta_info __rcu *sta_hash[STA_HASH_SIZE];
922
	struct timer_list sta_cleanup;
923
	int sta_generation;
924

925
	struct sk_buff_head pending[IEEE80211_MAX_QUEUES];
926
927
	struct tasklet_struct tx_pending_tasklet;

928
	atomic_t agg_queue_stop[IEEE80211_MAX_QUEUES];
929

930
931
	/* number of interfaces with corresponding IFF_ flags */
	atomic_t iff_allmultis, iff_promiscs;
932
933
934

	struct rate_control_ref *rate_ctrl;

935
936
	struct crypto_cipher *wep_tx_tfm;
	struct crypto_cipher *wep_rx_tfm;
937
938
	u32 wep_iv;

939
	/* see iface.c */
940
	struct list_head interfaces;
941
	struct mutex iflist_mtx;
942

943
	/*
Johannes Berg's avatar
Johannes Berg committed
944
	 * Key mutex, protects sdata's key_list and sta_info's
945
946
	 * key pointers (write access, they're RCU.)
	 */
Johannes Berg's avatar
Johannes Berg committed
947
	struct mutex key_mtx;
948

949
950
	/* mutex for scan and work locking */
	struct mutex mtx;
951

952
	/* Scanning and BSS list */
953
	unsigned long scanning;
954
	struct cfg80211_ssid scan_ssid;
955
	struct cfg80211_scan_request *int_scan_req;
956
	struct cfg80211_scan_request *scan_req, *hw_scan_req;
957
	struct ieee80211_channel *scan_channel;
958
	enum ieee80211_band hw_scan_band;
959
	int scan_channel_idx;
960
	int scan_ies_len;
961

962
963
	bool sched_scanning;
	struct ieee80211_sched_scan_ies sched_scan_ies;
964
	struct work_struct sched_scan_stopped_work;
965

966
	unsigned long leave_oper_channel_time;
967
	enum mac80211_scan_state next_scan_state;
968
	struct delayed_work scan_work;
969
	struct ieee80211_sub_if_data *scan_sdata;
970
	enum nl80211_channel_type _oper_channel_type;
971
	struct ieee80211_channel *oper_channel, *csa_channel;
972

973
974
975
976
	/* Temporary remain-on-channel for off-channel operations */
	struct ieee80211_channel *tmp_channel;
	enum nl80211_channel_type tmp_channel_type;

977
978
979
980
981
982
983
984
985
986
987
988
989
990
	/* 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;
991
	struct led_trigger *tx_led, *rx_led, *assoc_led, *radio_led;
992
	struct tpt_led_trigger *tpt_led_trigger;
993
994
	char tx_led_name[32], rx_led_name[32],
	     assoc_led_name[32], radio_led_name[32];
995
996
997
998
999
1000
#endif

#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
	/* TX/RX handler statistics */
	unsigned int tx_handlers_drop;
	unsigned int tx_handlers_queued;
For faster browsing, not all history is shown. View entire blame