ieee80211_i.h 33.8 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-2008	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 <net/ieee80211_radiotap.h>
27
#include <net/cfg80211.h>
28
#include <net/mac80211.h>
Johannes Berg's avatar
Johannes Berg committed
29
#include "key.h"
30 31
#include "sta_info.h"

32
struct ieee80211_local;
33 34 35 36 37 38 39 40 41 42 43 44

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

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

53 54 55 56 57 58
/*
 * Time after which we ignore scan results and no longer report/use
 * them in any way.
 */
#define IEEE80211_SCAN_RESULT_EXPIRE (10 * HZ)

59 60
#define TU_TO_EXP_TIME(x)	(jiffies + usecs_to_jiffies((x) * 1024))

61 62 63 64 65 66 67 68 69 70 71 72
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 */
};


73
struct ieee80211_bss {
74 75
	/* don't want to look up all the time */
	size_t ssid_len;
76
	u8 ssid[IEEE80211_MAX_SSID_LEN];
77

78
	u8 dtim_period;
79

80
	bool wmm_used;
81 82 83

	unsigned long last_probe_resp;

84 85 86
#ifdef CONFIG_MAC80211_MESH
	u8 *mesh_id;
	size_t mesh_id_len;
87
	u8 *mesh_cfg;
Johannes Berg's avatar
Johannes Berg committed
88
#endif
89

90 91 92 93
#define IEEE80211_MAX_SUPP_RATES 32
	u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
	size_t supp_rates_len;

94 95
	/*
	 * During assocation, we save an ERP value from a probe response so
96 97
	 * that we can feed ERP info to the driver when handling the
	 * association completes. these fields probably won't be up-to-date
98 99 100
	 * otherwise, you probably don't want to use them.
	 */
	bool has_erp_value;
101
	u8 erp_value;
102 103
};

104
static inline u8 *bss_mesh_cfg(struct ieee80211_bss *bss)
Johannes Berg's avatar
Johannes Berg committed
105 106 107 108 109 110 111
{
#ifdef CONFIG_MAC80211_MESH
	return bss->mesh_cfg;
#endif
	return NULL;
}

112
static inline u8 *bss_mesh_id(struct ieee80211_bss *bss)
Johannes Berg's avatar
Johannes Berg committed
113 114 115 116 117 118 119
{
#ifdef CONFIG_MAC80211_MESH
	return bss->mesh_id;
#endif
	return NULL;
}

120
static inline u8 bss_mesh_id_len(struct ieee80211_bss *bss)
Johannes Berg's avatar
Johannes Berg committed
121 122 123 124 125 126 127
{
#ifdef CONFIG_MAC80211_MESH
	return bss->mesh_id_len;
#endif
	return 0;
}

128

129 130 131 132 133
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)

134 135 136 137 138 139 140 141 142 143 144 145 146
#define IEEE80211_TX_FRAGMENTED		BIT(0)
#define IEEE80211_TX_UNICAST		BIT(1)
#define IEEE80211_TX_PS_BUFFERED	BIT(2)

struct ieee80211_tx_data {
	struct sk_buff *skb;
	struct ieee80211_local *local;
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;
	struct ieee80211_key *key;

	struct ieee80211_channel *channel;

147
	u16 ethertype;
148
	unsigned int flags;
149 150 151
};


152
typedef unsigned __bitwise__ ieee80211_rx_result;
Johannes Berg's avatar
Johannes Berg committed
153 154 155 156
#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)
157

158
#define IEEE80211_RX_IN_SCAN		BIT(0)
159
/* frame is destined to interface currently processed (incl. multicast frames) */
160 161
#define IEEE80211_RX_RA_MATCH		BIT(1)
#define IEEE80211_RX_AMSDU		BIT(2)
162
#define IEEE80211_RX_FRAGMENTED		BIT(3)
163
/* only add flags here that do not change with subframes of an aMPDU */
164 165

struct ieee80211_rx_data {
166 167 168 169 170
	struct sk_buff *skb;
	struct ieee80211_local *local;
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;
	struct ieee80211_key *key;
171 172

	unsigned int flags;
173 174 175
	int queue;
	u32 tkip_iv32;
	u16 tkip_iv16;
176 177
};

178 179 180 181 182 183
struct beacon_data {
	u8 *head, *tail;
	int head_len, tail_len;
	int dtim_period;
};

184
struct ieee80211_if_ap {
185
	struct beacon_data *beacon;
186

187 188
	struct list_head vlans;

189 190
	/* yes, this looks ugly, but guarantees that we can later use
	 * bitmap_empty :)
191
	 * NB: don't touch this bitmap, use sta_info_{set,clear}_tim_bit */
192 193
	u8 tim[sizeof(unsigned long) * BITS_TO_LONGS(IEEE80211_MAX_AID + 1)];
	struct sk_buff_head ps_bc_buf;
194
	atomic_t num_sta_ps; /* number of stations in PS mode */
195
	int dtim_count;
196 197 198 199
};

struct ieee80211_if_wds {
	struct sta_info *sta;
200
	u8 remote_addr[ETH_ALEN];
201 202 203
};

struct ieee80211_if_vlan {
204
	struct list_head list;
205 206 207

	/* used for all tx if the VLAN is configured to 4-addr mode */
	struct sta_info *sta;
208 209
};

210
struct mesh_stats {
211 212 213
	__u32 fwded_mcast;		/* Mesh forwarded multicast frames */
	__u32 fwded_unicast;		/* Mesh forwarded unicast frames */
	__u32 fwded_frames;		/* Mesh total forwarded frames */
214 215 216 217 218 219 220 221 222 223 224 225 226
	__u32 dropped_frames_ttl;	/* Not transmitted since mesh_ttl == 0*/
	__u32 dropped_frames_no_route;	/* Not transmitted, no route found */
	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;
};

227
enum ieee80211_work_type {
228
	IEEE80211_WORK_ABORT,
229
	IEEE80211_WORK_DIRECT_PROBE,
230 231
	IEEE80211_WORK_AUTH,
	IEEE80211_WORK_ASSOC,
232
	IEEE80211_WORK_REMAIN_ON_CHANNEL,
233 234
};

235 236 237 238 239 240 241 242 243 244 245 246
/**
 * 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,
};

247
struct ieee80211_work {
248 249
	struct list_head list;

250 251 252 253 254 255 256
	struct rcu_head rcu_head;

	struct ieee80211_sub_if_data *sdata;

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

257 258
	struct ieee80211_channel *chan;
	/* XXX: chan type? -- right now not really needed */
259

260 261 262
	unsigned long timeout;
	enum ieee80211_work_type type;

263 264
	u8 filter_ta[ETH_ALEN];

265 266 267 268 269 270 271 272 273
	union {
		struct {
			int tries;
			u16 algorithm, transaction;
			u8 ssid[IEEE80211_MAX_SSID_LEN];
			u8 ssid_len;
			u8 key[WLAN_KEY_LEN_WEP104];
			u8 key_len, key_idx;
			bool privacy;
274
		} probe_auth;
275
		struct {
276
			struct cfg80211_bss *bss;
277 278
			const u8 *supp_rates;
			const u8 *ht_information_ie;
279
			enum ieee80211_smps_mode smps;
280 281
			int tries;
			u16 capability;
282
			u8 prev_bssid[ETH_ALEN];
283 284 285
			u8 ssid[IEEE80211_MAX_SSID_LEN];
			u8 ssid_len;
			u8 supp_rates_len;
286
			bool wmm_used, use_11n;
287
		} assoc;
288 289 290
		struct {
			unsigned long timeout;
		} remain;
291
	};
Johannes Berg's avatar
Johannes Berg committed
292

293
	int ie_len;
294
	/* must be last */
295
	u8 ie[0];
296 297
};

298
/* flags used in struct ieee80211_if_managed.flags */
299
enum ieee80211_sta_flags {
300 301 302 303 304 305
	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),
306 307
};

308
struct ieee80211_if_managed {
309
	struct timer_list timer;
310 311
	struct timer_list conn_mon_timer;
	struct timer_list bcn_mon_timer;
Sujith's avatar
Sujith committed
312
	struct timer_list chswitch_timer;
313
	struct work_struct work;
314
	struct work_struct monitor_work;
Sujith's avatar
Sujith committed
315
	struct work_struct chswitch_work;
316
	struct work_struct beacon_loss_work;
317

318
	unsigned long probe_timeout;
319
	int probe_send_count;
320

321
	struct mutex mtx;
322
	struct cfg80211_bss *associated;
323

324
	u8 bssid[ETH_ALEN];
325

326 327
	u16 aid;

328 329
	struct sk_buff_head skb_queue;

330
	unsigned long timers_running; /* used for quiesce/restart */
331
	bool powersave; /* powersave requested for this iface */
332 333
	enum ieee80211_smps_mode req_smps, /* requested smps mode */
				 ap_smps; /* smps mode AP thinks we're in */
334

335
	unsigned int flags;
336

337 338
	u32 beacon_crc;

339 340 341 342 343 344
	enum {
		IEEE80211_MFP_DISABLED,
		IEEE80211_MFP_OPTIONAL,
		IEEE80211_MFP_REQUIRED
	} mfp; /* management frame protection */

345
	int wmm_last_param_set;
346 347

	u8 use_4addr;
348 349
};

350 351 352 353 354 355 356 357 358 359
enum ieee80211_ibss_request {
	IEEE80211_IBSS_REQ_RUN	= 0,
};

struct ieee80211_if_ibss {
	struct timer_list timer;
	struct work_struct work;

	struct sk_buff_head skb_queue;

360 361
	unsigned long request;
	unsigned long last_scan_completed;
362 363 364

	bool timer_running;

365 366
	bool fixed_bssid;
	bool fixed_channel;
Johannes Berg's avatar
Johannes Berg committed
367
	bool privacy;
368 369

	u8 bssid[ETH_ALEN];
370 371 372 373
	u8 ssid[IEEE80211_MAX_SSID_LEN];
	u8 ssid_len, ie_len;
	u8 *ie;
	struct ieee80211_channel *channel;
374 375

	unsigned long ibss_join_req;
376 377
	/* probe response/beacon for IBSS */
	struct sk_buff *presp, *skb;
378 379 380 381 382 383 384

	enum {
		IEEE80211_IBSS_MLME_SEARCH,
		IEEE80211_IBSS_MLME_JOINED,
	} state;
};

385 386 387 388
struct ieee80211_if_mesh {
	struct work_struct work;
	struct timer_list housekeeping_timer;
	struct timer_list mesh_path_timer;
389
	struct timer_list mesh_path_root_timer;
390 391
	struct sk_buff_head skb_queue;

392 393
	unsigned long timers_running;

394
	unsigned long wrkq_flags;
395 396 397 398

	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
399
	u8 mesh_pp_id;
400
	/* Active Path Selection Metric Identifier */
Rui Paulo's avatar
Rui Paulo committed
401
	u8 mesh_pm_id;
402
	/* Congestion Control Mode Identifier */
Rui Paulo's avatar
Rui Paulo committed
403
	u8 mesh_cc_id;
404
	/* Synchronization Protocol Identifier */
Rui Paulo's avatar
Rui Paulo committed
405
	u8 mesh_sp_id;
406
	/* Authentication Protocol Identifier */
Rui Paulo's avatar
Rui Paulo committed
407
	u8 mesh_auth_id;
408 409
	/* Local mesh Sequence Number */
	u32 sn;
410 411 412
	/* Last used PREQ ID */
	u32 preq_id;
	atomic_t mpaths;
413 414 415
	/* Timestamp of last SN update */
	unsigned long last_sn_update;
	/* Timestamp of last SN sent */
416 417 418 419 420 421 422 423 424 425
	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;
};
Johannes Berg's avatar
Johannes Berg committed
426 427

#ifdef CONFIG_MAC80211_MESH
428 429
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name)	\
	do { (msh)->mshstats.name++; } while (0)
Johannes Berg's avatar
Johannes Berg committed
430
#else
431
#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \
Johannes Berg's avatar
Johannes Berg committed
432 433
	do { } while (0)
#endif
434

435 436 437 438 439 440 441 442 443 444 445 446 447
/**
 * 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.
 */
enum ieee80211_sub_if_data_flags {
	IEEE80211_SDATA_ALLMULTI		= BIT(0),
	IEEE80211_SDATA_PROMISC			= BIT(1),
448 449
	IEEE80211_SDATA_OPERATING_GMODE		= BIT(2),
	IEEE80211_SDATA_DONT_BRIDGE_PACKETS	= BIT(3),
450 451
};

452 453 454 455 456
struct ieee80211_sub_if_data {
	struct list_head list;

	struct wireless_dev wdev;

457 458 459
	/* keys */
	struct list_head key_list;

460 461 462
	struct net_device *dev;
	struct ieee80211_local *local;

463
	unsigned int flags;
464

465 466
	int drop_unencrypted;

467 468
	char name[IFNAMSIZ];

469 470 471 472 473 474
	/*
	 * keep track of whether the HT opmode (stored in
	 * vif.bss_info.ht_operation_mode) is valid.
	 */
	bool ht_opmode_valid;

475 476 477 478 479
	/* Fragment table for host-based reassembly */
	struct ieee80211_fragment_entry	fragments[IEEE80211_FRAGMENT_MAX];
	unsigned int fragment_next;

#define NUM_DEFAULT_KEYS 4
480 481
#define NUM_DEFAULT_MGMT_KEYS 2
	struct ieee80211_key *keys[NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS];
482
	struct ieee80211_key *default_key;
483
	struct ieee80211_key *default_mgmt_key;
484

485 486
	u16 sequence_number;

487
	/*
488 489 490
	 * AP this belongs to: self in AP mode and
	 * corresponding AP in VLAN mode, NULL for
	 * all others (might be needed later in IBSS)
491
	 */
492 493 494 495
	struct ieee80211_if_ap *bss;

	int force_unicast_rateidx; /* forced TX rateidx for unicast frames */
	int max_ratectrl_rateidx; /* max TX rateidx for rate control */
496 497 498 499 500

	union {
		struct ieee80211_if_ap ap;
		struct ieee80211_if_wds wds;
		struct ieee80211_if_vlan vlan;
501 502
		struct ieee80211_if_managed mgd;
		struct ieee80211_if_ibss ibss;
503 504 505
#ifdef CONFIG_MAC80211_MESH
		struct ieee80211_if_mesh mesh;
#endif
506
		u32 mntr_flags;
507
	} u;
508 509

#ifdef CONFIG_MAC80211_DEBUGFS
510
	struct {
511
		struct dentry *dir;
512
		struct dentry *default_key;
513
		struct dentry *default_mgmt_key;
514
	} debugfs;
515
#endif
516 517
	/* must be last, dynamically sized area in this! */
	struct ieee80211_vif vif;
518 519
};

520 521 522 523 524 525
static inline
struct ieee80211_sub_if_data *vif_to_sdata(struct ieee80211_vif *p)
{
	return container_of(p, struct ieee80211_sub_if_data, vif);
}

526 527 528 529 530 531 532 533 534 535 536 537 538
static inline void
ieee80211_sdata_set_mesh_id(struct ieee80211_sub_if_data *sdata,
			    u8 mesh_id_len, u8 *mesh_id)
{
#ifdef CONFIG_MAC80211_MESH
	struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
	ifmsh->mesh_id_len = mesh_id_len;
	memcpy(ifmsh->mesh_id, mesh_id, mesh_id_len);
#else
	WARN_ON(1);
#endif
}

539 540 541
enum {
	IEEE80211_RX_MSG	= 1,
	IEEE80211_TX_STATUS_MSG	= 2,
542 543
	IEEE80211_DELBA_MSG	= 3,
	IEEE80211_ADDBA_MSG	= 4,
544 545
};

546 547
enum queue_stop_reason {
	IEEE80211_QUEUE_STOP_REASON_DRIVER,
548
	IEEE80211_QUEUE_STOP_REASON_PS,
549 550
	IEEE80211_QUEUE_STOP_REASON_CSA,
	IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
551
	IEEE80211_QUEUE_STOP_REASON_SUSPEND,
552
	IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
553 554
};

555 556 557 558 559 560 561 562 563 564
/**
 * 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
 * @SCAN_OFF_CHANNEL: We're off our operating channel for scanning,
 *	gets only set in conjunction with SCAN_SW_SCANNING
 */
565 566
enum {
	SCAN_SW_SCANNING,
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
	SCAN_HW_SCANNING,
	SCAN_OFF_CHANNEL,
};

/**
 * 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
 * @SCAN_LEAVE_OPER_CHANNEL: Leave the operating channel, notify the AP
 *	about us leaving the channel and stop all associated STA interfaces
 * @SCAN_ENTER_OPER_CHANNEL: Enter the operating channel again, notify the
 *	AP about us being back and restart all associated STA interfaces
 */
enum mac80211_scan_state {
	SCAN_DECISION,
	SCAN_SET_CHANNEL,
	SCAN_SEND_PROBE,
	SCAN_LEAVE_OPER_CHANNEL,
	SCAN_ENTER_OPER_CHANNEL,
590 591
};

592 593 594 595 596 597 598 599
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;

600 601 602 603 604 605 606 607 608
	/*
	 * work stuff, potentially off-channel (in the future)
	 */
	struct mutex work_mtx;
	struct list_head work_list;
	struct timer_list work_timer;
	struct work_struct work_work;
	struct sk_buff_head work_skb_queue;

609 610 611 612 613 614
	/*
	 * private workqueue to mac80211. mac80211 makes this accessible
	 * via ieee80211_queue_work()
	 */
	struct workqueue_struct *workqueue;

615
	unsigned long queue_stop_reasons[IEEE80211_MAX_QUEUES];
616
	/* also used to protect ampdu_ac_queue and amdpu_ac_stop_refcnt */
617
	spinlock_t queue_stop_reason_lock;
618

619
	int open_count;
620
	int monitors, cooked_mntrs;
621
	/* number of interfaces with corresponding FIF_ flags */
622
	int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss, fif_pspoll;
623
	unsigned int filter_flags; /* FIF_* */
Johannes Berg's avatar
Johannes Berg committed
624 625 626 627

	/* protects the aggregated multicast list and filter calls */
	spinlock_t filter_lock;

628 629 630
	/* used for uploading changed mc list */
	struct work_struct reconfig_filter;

631 632 633
	/* used to reconfigure hardware SM PS */
	struct work_struct recalc_smps;

Johannes Berg's avatar
Johannes Berg committed
634 635 636 637
	/* aggregated multicast list */
	struct dev_addr_list *mc_list;
	int mc_count;

638
	bool tim_in_locked_section; /* see ieee80211_beacon_get() */
639 640 641 642 643 644 645 646 647

	/*
	 * 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
648 649 650 651 652 653 654 655
	/*
	 * 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;

656 657 658 659 660 661
	/*
	 * quiescing is true during the suspend process _only_ to
	 * ease timer cancelling etc.
	 */
	bool quiescing;

662 663 664
	/* device is started */
	bool started;

665
	int tx_headroom; /* required headroom for hardware/radiotap */
666 667 668 669 670 671 672 673 674 675

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

676 677 678 679
	/* Station data */
	/*
	 * The lock only protects the list, hash, timer and counter
	 * against manipulation, reads are done in RCU. Additionally,
680
	 * the lock protects each BSS's TIM bitmap.
681 682 683
	 */
	spinlock_t sta_lock;
	unsigned long num_sta;
684 685 686
	struct list_head sta_list;
	struct sta_info *sta_hash[STA_HASH_SIZE];
	struct timer_list sta_cleanup;
687
	int sta_generation;
688

689
	struct sk_buff_head pending[IEEE80211_MAX_QUEUES];
690 691
	struct tasklet_struct tx_pending_tasklet;

692 693 694 695 696 697 698 699
	/*
	 * This lock is used to prevent concurrent A-MPDU
	 * session start/stop processing, this thus also
	 * synchronises the ->ampdu_action() callback to
	 * drivers and limits it to one at a time.
	 */
	spinlock_t ampdu_lock;

700 701
	/* number of interfaces with corresponding IFF_ flags */
	atomic_t iff_allmultis, iff_promiscs;
702 703 704 705 706 707 708

	struct rate_control_ref *rate_ctrl;

	struct crypto_blkcipher *wep_tx_tfm;
	struct crypto_blkcipher *wep_rx_tfm;
	u32 wep_iv;

709
	/* see iface.c */
710
	struct list_head interfaces;
711
	struct mutex iflist_mtx;
712

713 714 715 716 717 718 719
	/*
	 * Key lock, protects sdata's key_list and sta_info's
	 * key pointers (write access, they're RCU.)
	 */
	spinlock_t key_lock;


720
	/* Scanning and BSS list */
721
	struct mutex scan_mtx;
722
	unsigned long scanning;
723
	struct cfg80211_ssid scan_ssid;
724
	struct cfg80211_scan_request *int_scan_req;
725
	struct cfg80211_scan_request *scan_req, *hw_scan_req;
726
	struct ieee80211_channel *scan_channel;
727
	enum ieee80211_band hw_scan_band;
728
	int scan_channel_idx;
729
	int scan_ies_len;
730

731
	enum mac80211_scan_state next_scan_state;
732
	struct delayed_work scan_work;
733
	struct ieee80211_sub_if_data *scan_sdata;
Sujith's avatar
Sujith committed
734
	enum nl80211_channel_type oper_channel_type;
735
	struct ieee80211_channel *oper_channel, *csa_channel;
736

737 738 739 740
	/* Temporary remain-on-channel for off-channel operations */
	struct ieee80211_channel *tmp_channel;
	enum nl80211_channel_type tmp_channel_type;

741 742 743 744 745 746 747 748 749 750 751 752 753 754
	/* 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;
755 756 757
	struct led_trigger *tx_led, *rx_led, *assoc_led, *radio_led;
	char tx_led_name[32], rx_led_name[32],
	     assoc_led_name[32], radio_led_name[32];
758 759
#endif

760 761 762 763
#ifdef CONFIG_MAC80211_DEBUGFS
	struct work_struct sta_debugfs_add;
#endif

764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795
#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 rx_handlers_drop_passive_scan;
	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
				*/
	int wifi_wme_noack_test;
	unsigned int wmm_acm; /* bit field of ACM bits (BIT(802.1D tag)) */
796

797
	bool pspolling;
798
	bool offchannel_ps_enabled;
799 800 801 802 803
	/*
	 * 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;
804 805 806
	struct work_struct dynamic_ps_enable_work;
	struct work_struct dynamic_ps_disable_work;
	struct timer_list dynamic_ps_timer;
807
	struct notifier_block network_latency_notifier;
808

809
	int user_power_level; /* in dBm */
810
	int power_constr_level; /* in dBm */
811

812 813
	enum ieee80211_smps_mode smps_mode;

814 815
	struct work_struct restart_work;

816 817
#ifdef CONFIG_MAC80211_DEBUGFS
	struct local_debugfsdentries {
818
		struct dentry *rcdir;
819 820 821 822
		struct dentry *stations;
		struct dentry *keys;
	} debugfs;
#endif
823 824
};

825 826 827 828 829 830
static inline struct ieee80211_sub_if_data *
IEEE80211_DEV_TO_SUB_IF(struct net_device *dev)
{
	return netdev_priv(dev);
}

831
/* this struct represents 802.11n's RA/TID combination along with our vif */
832
struct ieee80211_ra_tid {
833
	struct ieee80211_vif *vif;
834 835 836 837
	u8 ra[ETH_ALEN];
	u16 tid;
};

838 839
/* Parsed Information Elements */
struct ieee802_11_elems {
840 841 842
	u8 *ie_start;
	size_t total_len;

843 844 845 846 847 848
	/* pointers to IEs */
	u8 *ssid;
	u8 *supp_rates;
	u8 *fh_params;
	u8 *ds_params;
	u8 *cf_params;
849
	struct ieee80211_tim_ie *tim;
850 851 852 853 854 855 856 857
	u8 *ibss_params;
	u8 *challenge;
	u8 *wpa;
	u8 *rsn;
	u8 *erp_info;
	u8 *ext_supp_rates;
	u8 *wmm_info;
	u8 *wmm_param;
858
	struct ieee80211_ht_cap *ht_cap_elem;
859
	struct ieee80211_ht_info *ht_info_elem;
860
	struct ieee80211_meshconf_ie *mesh_config;
861 862 863 864 865
	u8 *mesh_id;
	u8 *peer_link;
	u8 *preq;
	u8 *prep;
	u8 *perr;
866
	struct ieee80211_rann_ie *rann;
867 868 869 870
	u8 *ch_switch_elem;
	u8 *country_elem;
	u8 *pwr_constr_elem;
	u8 *quiet_elem; 	/* first quite element */
871
	u8 *timeout_int;
872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892

	/* length of them, respectively */
	u8 ssid_len;
	u8 supp_rates_len;
	u8 fh_params_len;
	u8 ds_params_len;
	u8 cf_params_len;
	u8 tim_len;
	u8 ibss_params_len;
	u8 challenge_len;
	u8 wpa_len;
	u8 rsn_len;
	u8 erp_info_len;
	u8 ext_supp_rates_len;
	u8 wmm_info_len;
	u8 wmm_param_len;
	u8 mesh_id_len;
	u8 peer_link_len;
	u8 preq_len;
	u8 prep_len;
	u8 perr_len;
893 894 895 896 897
	u8 ch_switch_elem_len;
	u8 country_elem_len;
	u8 pwr_constr_elem_len;
	u8 quiet_elem_len;
	u8 num_of_quiet_elem;	/* can be more the one */
898
	u8 timeout_int_len;
899 900
};

901 902 903 904 905 906 907 908 909 910 911 912 913
static inline struct ieee80211_local *hw_to_local(
	struct ieee80211_hw *hw)
{
	return container_of(hw, struct ieee80211_local, hw);
}

static inline struct ieee80211_hw *local_to_hw(
	struct ieee80211_local *local)
{
	return &local->hw;
}


914 915 916 917 918 919 920
static inline int ieee80211_bssid_match(const u8 *raddr, const u8 *addr)
{
	return compare_ether_addr(raddr, addr) == 0 ||
	       is_broadcast_ether_addr(raddr);
}


921
int ieee80211_hw_config(struct ieee80211_local *local, u32 changed);
922
void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx);
923 924
void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
				      u32 changed);
925
void ieee80211_configure_filter(struct ieee80211_local *local);
926
u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata);
927

928 929
extern bool ieee80211_disable_40mhz_24ghz;

930
/* STA code */
931
void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata);
932 933 934 935 936
int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
		       struct cfg80211_auth_request *req);
int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
			struct cfg80211_assoc_request *req);
int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
Johannes Berg's avatar
Johannes Berg committed
937 938
			 struct cfg80211_deauth_request *req,
			 void *cookie);
939
int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
Johannes Berg's avatar
Johannes Berg committed
940 941
			   struct cfg80211_disassoc_request *req,
			   void *cookie);
942
ieee80211_rx_result ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata,
943
					  struct sk_buff *skb);
944 945
void ieee80211_send_pspoll(struct ieee80211_local *local,
			   struct ieee80211_sub_if_data *sdata);
946 947 948
void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency);
int ieee80211_max_network_latency(struct notifier_block *nb,
				  unsigned long data, void *dummy);
949 950 951
void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
				      struct ieee80211_channel_sw_ie *sw_elem,
				      struct ieee80211_bss *bss);
952 953
void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata);
void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata);
954

955 956 957 958
/* IBSS code */
void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local);
void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata);
ieee80211_rx_result
959
ieee80211_ibss_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb);
960 961
struct sta_info *ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata,
					u8 *bssid, u8 *addr, u32 supp_rates);
962 963 964
int ieee80211_ibss_join(struct ieee80211_sub_if_data *sdata,
			struct cfg80211_ibss_params *params);
int ieee80211_ibss_leave(struct ieee80211_sub_if_data *sdata);
965 966
void ieee80211_ibss_quiesce(struct ieee80211_sub_if_data *sdata);
void ieee80211_ibss_restart(struct ieee80211_sub_if_data *sdata);
967

968
/* scan/BSS handling */
969
void ieee80211_scan_work(struct work_struct *work);
970 971
int ieee80211_request_internal_scan(struct ieee80211_sub_if_data *sdata,
				    const u8 *ssid, u8 ssid_len);
972
int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
973
			   struct cfg80211_scan_request *req);
974
void ieee80211_scan_cancel(struct ieee80211_local *local);
975
ieee80211_rx_result
976
ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb);
977

978
void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local);
979
struct ieee80211_bss *
980 981 982 983 984
ieee80211_bss_info_update(struct ieee80211_local *local,
			  struct ieee80211_rx_status *rx_status,
			  struct ieee80211_mgmt *mgmt,
			  size_t len,
			  struct ieee802_11_elems *elems,
985 986
			  struct ieee80211_channel *channel,
			  bool beacon);
987
struct ieee80211_bss *
988 989
ieee80211_rx_bss_get(struct ieee80211_local *local, u8 *bssid, int freq,
		     u8 *ssid, u8 ssid_len);
990
void ieee80211_rx_bss_put(struct ieee80211_local *local,