]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame_incremental - net/mac80211/ieee80211_i.h
projects / mirror_ubuntu-artful-kernel.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
mac80211: stop Rx during HW reconfig
[mirror_ubuntu-artful-kernel.git] / net / mac80211 / ieee80211_i.h
... / ...
CommitLineData
1/*
2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005, Devicescape Software, Inc.
4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
5 * Copyright 2007-2010 Johannes Berg <johannes@sipsolutions.net>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12#ifndef IEEE80211_I_H
13#define IEEE80211_I_H
14
15#include <linux/kernel.h>
16#include <linux/device.h>
17#include <linux/if_ether.h>
18#include <linux/interrupt.h>
19#include <linux/list.h>
20#include <linux/netdevice.h>
21#include <linux/skbuff.h>
22#include <linux/workqueue.h>
23#include <linux/types.h>
24#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>
31#include "key.h"
32#include "sta_info.h"
33
34struct ieee80211_local;
35
36/* Maximum number of broadcast/multicast frames to buffer when some of the
37 * associated stations are using power saving. */
38#define AP_MAX_BC_BUFFER 128
39
40/* Maximum number of frames buffered to all STAs, including multicast frames.
41 * Note: increasing this limit increases the potential memory requirement. Each
42 * frame can be up to about 2 kB long. */
43#define TOTAL_MAX_TX_BUFFER 512
44
45/* Required encryption head and tailroom */
46#define IEEE80211_ENCRYPT_HEADROOM 8
47#define IEEE80211_ENCRYPT_TAILROOM 18
48
49/* IEEE 802.11 (Ch. 9.5 Defragmentation) requires support for concurrent
50 * reception of at least three fragmented frames. This limit can be increased
51 * by changing this define, at the cost of slower frame reassembly and
52 * increased memory use (about 2 kB of RAM per entry). */
53#define IEEE80211_FRAGMENT_MAX 4
54
55#define TU_TO_JIFFIES(x) (usecs_to_jiffies((x) * 1024))
56#define TU_TO_EXP_TIME(x) (jiffies + TU_TO_JIFFIES(x))
57
58#define IEEE80211_DEFAULT_UAPSD_QUEUES \
59 (IEEE80211_WMM_IE_STA_QOSINFO_AC_BK | \
60 IEEE80211_WMM_IE_STA_QOSINFO_AC_BE | \
61 IEEE80211_WMM_IE_STA_QOSINFO_AC_VI | \
62 IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
63
64#define IEEE80211_DEFAULT_MAX_SP_LEN \
65 IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL
66
67struct ieee80211_fragment_entry {
68 unsigned long first_frag_time;
69 unsigned int seq;
70 unsigned int rx_queue;
71 unsigned int last_frag;
72 unsigned int extra_len;
73 struct sk_buff_head skb_list;
74 int ccmp; /* Whether fragments were encrypted with CCMP */
75 u8 last_pn[6]; /* PN of the last fragment if CCMP was used */
76};
77
78
79struct ieee80211_bss {
80 /* don't want to look up all the time */
81 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 unsigned long last_probe_resp;
90
91#ifdef CONFIG_MAC80211_MESH
92 u8 *mesh_id;
93 size_t mesh_id_len;
94 u8 *mesh_cfg;
95#endif
96
97#define IEEE80211_MAX_SUPP_RATES 32
98 u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
99 size_t supp_rates_len;
100
101 /*
102 * During association, we save an ERP value from a probe response so
103 * that we can feed ERP info to the driver when handling the
104 * association completes. these fields probably won't be up-to-date
105 * otherwise, you probably don't want to use them.
106 */
107 bool has_erp_value;
108 u8 erp_value;
109
110 /* Keep track of the corruption of the last beacon/probe response. */
111 u8 corrupt_data;
112
113 /* Keep track of what bits of information we have valid info for. */
114 u8 valid_data;
115};
116
117/**
118 * enum ieee80211_corrupt_data_flags - BSS data corruption flags
119 * @IEEE80211_BSS_CORRUPT_BEACON: last beacon frame received was corrupted
120 * @IEEE80211_BSS_CORRUPT_PROBE_RESP: last probe response received was corrupted
121 *
122 * These are bss flags that are attached to a bss in the
123 * @corrupt_data field of &struct ieee80211_bss.
124 */
125enum ieee80211_bss_corrupt_data_flags {
126 IEEE80211_BSS_CORRUPT_BEACON = BIT(0),
127 IEEE80211_BSS_CORRUPT_PROBE_RESP = BIT(1)
128};
129
130/**
131 * enum ieee80211_valid_data_flags - BSS valid data flags
132 * @IEEE80211_BSS_VALID_DTIM: DTIM data was gathered from non-corrupt IE
133 * @IEEE80211_BSS_VALID_WMM: WMM/UAPSD data was gathered from non-corrupt IE
134 * @IEEE80211_BSS_VALID_RATES: Supported rates were gathered from non-corrupt IE
135 * @IEEE80211_BSS_VALID_ERP: ERP flag was gathered from non-corrupt IE
136 *
137 * These are bss flags that are attached to a bss in the
138 * @valid_data field of &struct ieee80211_bss. They show which parts
139 * of the data structure were recieved as a result of an un-corrupted
140 * beacon/probe response.
141 */
142enum ieee80211_bss_valid_data_flags {
143 IEEE80211_BSS_VALID_DTIM = BIT(0),
144 IEEE80211_BSS_VALID_WMM = BIT(1),
145 IEEE80211_BSS_VALID_RATES = BIT(2),
146 IEEE80211_BSS_VALID_ERP = BIT(3)
147};
148
149static inline u8 *bss_mesh_cfg(struct ieee80211_bss *bss)
150{
151#ifdef CONFIG_MAC80211_MESH
152 return bss->mesh_cfg;
153#endif
154 return NULL;
155}
156
157static inline u8 *bss_mesh_id(struct ieee80211_bss *bss)
158{
159#ifdef CONFIG_MAC80211_MESH
160 return bss->mesh_id;
161#endif
162 return NULL;
163}
164
165static inline u8 bss_mesh_id_len(struct ieee80211_bss *bss)
166{
167#ifdef CONFIG_MAC80211_MESH
168 return bss->mesh_id_len;
169#endif
170 return 0;
171}
172
173
174typedef unsigned __bitwise__ ieee80211_tx_result;
175#define TX_CONTINUE ((__force ieee80211_tx_result) 0u)
176#define TX_DROP ((__force ieee80211_tx_result) 1u)
177#define TX_QUEUED ((__force ieee80211_tx_result) 2u)
178
179#define IEEE80211_TX_UNICAST BIT(1)
180#define IEEE80211_TX_PS_BUFFERED BIT(2)
181
182struct ieee80211_tx_data {
183 struct sk_buff *skb;
184 struct sk_buff_head skbs;
185 struct ieee80211_local *local;
186 struct ieee80211_sub_if_data *sdata;
187 struct sta_info *sta;
188 struct ieee80211_key *key;
189
190 struct ieee80211_channel *channel;
191
192 unsigned int flags;
193};
194
195
196typedef unsigned __bitwise__ ieee80211_rx_result;
197#define RX_CONTINUE ((__force ieee80211_rx_result) 0u)
198#define RX_DROP_UNUSABLE ((__force ieee80211_rx_result) 1u)
199#define RX_DROP_MONITOR ((__force ieee80211_rx_result) 2u)
200#define RX_QUEUED ((__force ieee80211_rx_result) 3u)
201
202/**
203 * enum ieee80211_packet_rx_flags - packet RX flags
204 * @IEEE80211_RX_RA_MATCH: frame is destined to interface currently processed
205 * (incl. multicast frames)
206 * @IEEE80211_RX_IN_SCAN: received while scanning
207 * @IEEE80211_RX_FRAGMENTED: fragmented frame
208 * @IEEE80211_RX_AMSDU: a-MSDU packet
209 * @IEEE80211_RX_MALFORMED_ACTION_FRM: action frame is malformed
210 * @IEEE80211_RX_DEFERRED_RELEASE: frame was subjected to receive reordering
211 *
212 * These are per-frame flags that are attached to a frame in the
213 * @rx_flags field of &struct ieee80211_rx_status.
214 */
215enum ieee80211_packet_rx_flags {
216 IEEE80211_RX_IN_SCAN = BIT(0),
217 IEEE80211_RX_RA_MATCH = BIT(1),
218 IEEE80211_RX_FRAGMENTED = BIT(2),
219 IEEE80211_RX_AMSDU = BIT(3),
220 IEEE80211_RX_MALFORMED_ACTION_FRM = BIT(4),
221 IEEE80211_RX_DEFERRED_RELEASE = BIT(5),
222};
223
224/**
225 * enum ieee80211_rx_flags - RX data flags
226 *
227 * @IEEE80211_RX_CMNTR: received on cooked monitor already
228 * @IEEE80211_RX_BEACON_REPORTED: This frame was already reported
229 * to cfg80211_report_obss_beacon().
230 *
231 * These flags are used across handling multiple interfaces
232 * for a single frame.
233 */
234enum ieee80211_rx_flags {
235 IEEE80211_RX_CMNTR = BIT(0),
236 IEEE80211_RX_BEACON_REPORTED = BIT(1),
237};
238
239struct ieee80211_rx_data {
240 struct sk_buff *skb;
241 struct ieee80211_local *local;
242 struct ieee80211_sub_if_data *sdata;
243 struct sta_info *sta;
244 struct ieee80211_key *key;
245
246 unsigned int flags;
247
248 /*
249 * Index into sequence numbers array, 0..16
250 * since the last (16) is used for non-QoS,
251 * will be 16 on non-QoS frames.
252 */
253 int seqno_idx;
254
255 /*
256 * Index into the security IV/PN arrays, 0..16
257 * since the last (16) is used for CCMP-encrypted
258 * management frames, will be set to 16 on mgmt
259 * frames and 0 on non-QoS frames.
260 */
261 int security_idx;
262
263 u32 tkip_iv32;
264 u16 tkip_iv16;
265};
266
267struct beacon_data {
268 u8 *head, *tail;
269 int head_len, tail_len;
270 struct rcu_head rcu_head;
271};
272
273struct ieee80211_if_ap {
274 struct beacon_data __rcu *beacon;
275 struct sk_buff __rcu *probe_resp;
276
277 struct list_head vlans;
278
279 /* yes, this looks ugly, but guarantees that we can later use
280 * bitmap_empty :)
281 * NB: don't touch this bitmap, use sta_info_{set,clear}_tim_bit */
282 u8 tim[sizeof(unsigned long) * BITS_TO_LONGS(IEEE80211_MAX_AID + 1)];
283 struct sk_buff_head ps_bc_buf;
284 atomic_t num_sta_ps; /* number of stations in PS mode */
285 atomic_t num_mcast_sta; /* number of stations receiving multicast */
286 int dtim_count;
287 bool dtim_bc_mc;
288};
289
290struct ieee80211_if_wds {
291 struct sta_info *sta;
292 u8 remote_addr[ETH_ALEN];
293};
294
295struct 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
302struct mesh_stats {
303 __u32 fwded_mcast; /* Mesh forwarded multicast frames */
304 __u32 fwded_unicast; /* Mesh forwarded unicast frames */
305 __u32 fwded_frames; /* Mesh total forwarded frames */
306 __u32 dropped_frames_ttl; /* Not transmitted since mesh_ttl == 0*/
307 __u32 dropped_frames_no_route; /* Not transmitted, no route found */
308 __u32 dropped_frames_congestion;/* Not forwarded due to congestion */
309 atomic_t estab_plinks;
310};
311
312#define PREQ_Q_F_START 0x1
313#define PREQ_Q_F_REFRESH 0x2
314struct mesh_preq_queue {
315 struct list_head list;
316 u8 dst[ETH_ALEN];
317 u8 flags;
318};
319
320#if HZ/100 == 0
321#define IEEE80211_ROC_MIN_LEFT 1
322#else
323#define IEEE80211_ROC_MIN_LEFT (HZ/100)
324#endif
325
326struct ieee80211_roc_work {
327 struct list_head list;
328 struct list_head dependents;
329
330 struct delayed_work work;
331
332 struct ieee80211_sub_if_data *sdata;
333
334 struct ieee80211_channel *chan;
335 enum nl80211_channel_type chan_type;
336
337 bool started, abort, hw_begun, notified;
338
339 unsigned long hw_start_time;
340
341 u32 duration, req_duration;
342 struct sk_buff *frame;
343 u64 mgmt_tx_cookie;
344};
345
346/* flags used in struct ieee80211_if_managed.flags */
347enum ieee80211_sta_flags {
348 IEEE80211_STA_BEACON_POLL = BIT(0),
349 IEEE80211_STA_CONNECTION_POLL = BIT(1),
350 IEEE80211_STA_CONTROL_PORT = BIT(2),
351 IEEE80211_STA_DISABLE_11N = BIT(4),
352 IEEE80211_STA_CSA_RECEIVED = BIT(5),
353 IEEE80211_STA_MFP_ENABLED = BIT(6),
354 IEEE80211_STA_UAPSD_ENABLED = BIT(7),
355 IEEE80211_STA_NULLFUNC_ACKED = BIT(8),
356 IEEE80211_STA_RESET_SIGNAL_AVE = BIT(9),
357 IEEE80211_STA_DISABLE_40MHZ = BIT(10),
358};
359
360struct ieee80211_mgd_auth_data {
361 struct cfg80211_bss *bss;
362 unsigned long timeout;
363 int tries;
364 u16 algorithm, expected_transaction;
365
366 u8 key[WLAN_KEY_LEN_WEP104];
367 u8 key_len, key_idx;
368 bool done;
369
370 size_t ie_len;
371 u8 ie[];
372};
373
374struct ieee80211_mgd_assoc_data {
375 struct cfg80211_bss *bss;
376 const u8 *supp_rates;
377
378 unsigned long timeout;
379 int tries;
380
381 u16 capability;
382 u8 prev_bssid[ETH_ALEN];
383 u8 ssid[IEEE80211_MAX_SSID_LEN];
384 u8 ssid_len;
385 u8 supp_rates_len;
386 bool wmm, uapsd;
387 bool have_beacon;
388 bool sent_assoc;
389 bool synced;
390
391 u8 ap_ht_param;
392
393 size_t ie_len;
394 u8 ie[];
395};
396
397struct ieee80211_if_managed {
398 struct timer_list timer;
399 struct timer_list conn_mon_timer;
400 struct timer_list bcn_mon_timer;
401 struct timer_list chswitch_timer;
402 struct work_struct monitor_work;
403 struct work_struct chswitch_work;
404 struct work_struct beacon_connection_loss_work;
405
406 unsigned long beacon_timeout;
407 unsigned long probe_timeout;
408 int probe_send_count;
409 bool nullfunc_failed;
410
411 struct mutex mtx;
412 struct cfg80211_bss *associated;
413 struct ieee80211_mgd_auth_data *auth_data;
414 struct ieee80211_mgd_assoc_data *assoc_data;
415
416 u8 bssid[ETH_ALEN];
417
418 u16 aid;
419
420 unsigned long timers_running; /* used for quiesce/restart */
421 bool powersave; /* powersave requested for this iface */
422 bool broken_ap; /* AP is broken -- turn off powersave */
423 enum ieee80211_smps_mode req_smps, /* requested smps mode */
424 ap_smps, /* smps mode AP thinks we're in */
425 driver_smps_mode; /* smps mode request */
426
427 struct work_struct request_smps_work;
428
429 unsigned int flags;
430
431 bool beacon_crc_valid;
432 u32 beacon_crc;
433
434 enum {
435 IEEE80211_MFP_DISABLED,
436 IEEE80211_MFP_OPTIONAL,
437 IEEE80211_MFP_REQUIRED
438 } mfp; /* management frame protection */
439
440 /*
441 * Bitmask of enabled u-apsd queues,
442 * IEEE80211_WMM_IE_STA_QOSINFO_AC_BE & co. Needs a new association
443 * to take effect.
444 */
445 unsigned int uapsd_queues;
446
447 /*
448 * Maximum number of buffered frames AP can deliver during a
449 * service period, IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL or similar.
450 * Needs a new association to take effect.
451 */
452 unsigned int uapsd_max_sp_len;
453
454 int wmm_last_param_set;
455
456 u8 use_4addr;
457
458 /* Signal strength from the last Beacon frame in the current BSS. */
459 int last_beacon_signal;
460
461 /*
462 * Weighted average of the signal strength from Beacon frames in the
463 * current BSS. This is in units of 1/16 of the signal unit to maintain
464 * accuracy and to speed up calculations, i.e., the value need to be
465 * divided by 16 to get the actual value.
466 */
467 int ave_beacon_signal;
468
469 /*
470 * Number of Beacon frames used in ave_beacon_signal. This can be used
471 * to avoid generating less reliable cqm events that would be based
472 * only on couple of received frames.
473 */
474 unsigned int count_beacon_signal;
475
476 /*
477 * Last Beacon frame signal strength average (ave_beacon_signal / 16)
478 * that triggered a cqm event. 0 indicates that no event has been
479 * generated for the current association.
480 */
481 int last_cqm_event_signal;
482
483 /*
484 * State variables for keeping track of RSSI of the AP currently
485 * connected to and informing driver when RSSI has gone
486 * below/above a certain threshold.
487 */
488 int rssi_min_thold, rssi_max_thold;
489 int last_ave_beacon_signal;
490
491 struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
492 struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */
493};
494
495struct ieee80211_if_ibss {
496 struct timer_list timer;
497
498 struct mutex mtx;
499
500 unsigned long last_scan_completed;
501
502 u32 basic_rates;
503
504 bool timer_running;
505
506 bool fixed_bssid;
507 bool fixed_channel;
508 bool privacy;
509
510 bool control_port;
511
512 u8 bssid[ETH_ALEN] __aligned(2);
513 u8 ssid[IEEE80211_MAX_SSID_LEN];
514 u8 ssid_len, ie_len;
515 u8 *ie;
516 struct ieee80211_channel *channel;
517 enum nl80211_channel_type channel_type;
518
519 unsigned long ibss_join_req;
520 /* probe response/beacon for IBSS */
521 struct sk_buff __rcu *presp;
522 struct sk_buff *skb;
523
524 spinlock_t incomplete_lock;
525 struct list_head incomplete_stations;
526
527 enum {
528 IEEE80211_IBSS_MLME_SEARCH,
529 IEEE80211_IBSS_MLME_JOINED,
530 } state;
531};
532
533/**
534 * struct ieee80211_mesh_sync_ops - Extensible synchronization framework interface
535 *
536 * these declarations define the interface, which enables
537 * vendor-specific mesh synchronization
538 *
539 */
540struct ieee802_11_elems;
541struct ieee80211_mesh_sync_ops {
542 void (*rx_bcn_presp)(struct ieee80211_sub_if_data *sdata,
543 u16 stype,
544 struct ieee80211_mgmt *mgmt,
545 struct ieee802_11_elems *elems,
546 struct ieee80211_rx_status *rx_status);
547 void (*adjust_tbtt)(struct ieee80211_sub_if_data *sdata);
548 /* add other framework functions here */
549};
550
551struct ieee80211_if_mesh {
552 struct timer_list housekeeping_timer;
553 struct timer_list mesh_path_timer;
554 struct timer_list mesh_path_root_timer;
555
556 unsigned long timers_running;
557
558 unsigned long wrkq_flags;
559
560 u8 mesh_id[IEEE80211_MAX_MESH_ID_LEN];
561 size_t mesh_id_len;
562 /* Active Path Selection Protocol Identifier */
563 u8 mesh_pp_id;
564 /* Active Path Selection Metric Identifier */
565 u8 mesh_pm_id;
566 /* Congestion Control Mode Identifier */
567 u8 mesh_cc_id;
568 /* Synchronization Protocol Identifier */
569 u8 mesh_sp_id;
570 /* Authentication Protocol Identifier */
571 u8 mesh_auth_id;
572 /* Local mesh Sequence Number */
573 u32 sn;
574 /* Last used PREQ ID */
575 u32 preq_id;
576 atomic_t mpaths;
577 /* Timestamp of last SN update */
578 unsigned long last_sn_update;
579 /* Time when it's ok to send next PERR */
580 unsigned long next_perr;
581 /* Timestamp of last PREQ sent */
582 unsigned long last_preq;
583 struct mesh_rmc *rmc;
584 spinlock_t mesh_preq_queue_lock;
585 struct mesh_preq_queue preq_queue;
586 int preq_queue_len;
587 struct mesh_stats mshstats;
588 struct mesh_config mshcfg;
589 u32 mesh_seqnum;
590 bool accepting_plinks;
591 int num_gates;
592 const u8 *ie;
593 u8 ie_len;
594 enum {
595 IEEE80211_MESH_SEC_NONE = 0x0,
596 IEEE80211_MESH_SEC_AUTHED = 0x1,
597 IEEE80211_MESH_SEC_SECURED = 0x2,
598 } security;
599 /* Extensible Synchronization Framework */
600 struct ieee80211_mesh_sync_ops *sync_ops;
601 s64 sync_offset_clockdrift_max;
602 spinlock_t sync_offset_lock;
603 bool adjusting_tbtt;
604};
605
606#ifdef CONFIG_MAC80211_MESH
607#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \
608 do { (msh)->mshstats.name++; } while (0)
609#else
610#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \
611 do { } while (0)
612#endif
613
614/**
615 * enum ieee80211_sub_if_data_flags - virtual interface flags
616 *
617 * @IEEE80211_SDATA_ALLMULTI: interface wants all multicast packets
618 * @IEEE80211_SDATA_PROMISC: interface is promisc
619 * @IEEE80211_SDATA_OPERATING_GMODE: operating in G-only mode
620 * @IEEE80211_SDATA_DONT_BRIDGE_PACKETS: bridge packets between
621 * associated stations and deliver multicast frames both
622 * back to wireless media and to the local net stack.
623 * @IEEE80211_SDATA_DISCONNECT_RESUME: Disconnect after resume.
624 * @IEEE80211_SDATA_IN_DRIVER: indicates interface was added to driver
625 */
626enum ieee80211_sub_if_data_flags {
627 IEEE80211_SDATA_ALLMULTI = BIT(0),
628 IEEE80211_SDATA_PROMISC = BIT(1),
629 IEEE80211_SDATA_OPERATING_GMODE = BIT(2),
630 IEEE80211_SDATA_DONT_BRIDGE_PACKETS = BIT(3),
631 IEEE80211_SDATA_DISCONNECT_RESUME = BIT(4),
632 IEEE80211_SDATA_IN_DRIVER = BIT(5),
633};
634
635/**
636 * enum ieee80211_sdata_state_bits - virtual interface state bits
637 * @SDATA_STATE_RUNNING: virtual interface is up & running; this
638 * mirrors netif_running() but is separate for interface type
639 * change handling while the interface is up
640 * @SDATA_STATE_OFFCHANNEL: This interface is currently in offchannel
641 * mode, so queues are stopped
642 */
643enum ieee80211_sdata_state_bits {
644 SDATA_STATE_RUNNING,
645 SDATA_STATE_OFFCHANNEL,
646};
647
648struct ieee80211_sub_if_data {
649 struct list_head list;
650
651 struct wireless_dev wdev;
652
653 /* keys */
654 struct list_head key_list;
655
656 /* count for keys needing tailroom space allocation */
657 int crypto_tx_tailroom_needed_cnt;
658
659 struct net_device *dev;
660 struct ieee80211_local *local;
661
662 unsigned int flags;
663
664 unsigned long state;
665
666 int drop_unencrypted;
667
668 char name[IFNAMSIZ];
669
670 /* to detect idle changes */
671 bool old_idle;
672
673 /* Fragment table for host-based reassembly */
674 struct ieee80211_fragment_entry fragments[IEEE80211_FRAGMENT_MAX];
675 unsigned int fragment_next;
676
677 /* TID bitmap for NoAck policy */
678 u16 noack_map;
679
680 struct ieee80211_key __rcu *keys[NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS];
681 struct ieee80211_key __rcu *default_unicast_key;
682 struct ieee80211_key __rcu *default_multicast_key;
683 struct ieee80211_key __rcu *default_mgmt_key;
684
685 u16 sequence_number;
686 __be16 control_port_protocol;
687 bool control_port_no_encrypt;
688
689 struct ieee80211_tx_queue_params tx_conf[IEEE80211_NUM_ACS];
690
691 struct work_struct work;
692 struct sk_buff_head skb_queue;
693
694 bool arp_filter_state;
695
696 /*
697 * AP this belongs to: self in AP mode and
698 * corresponding AP in VLAN mode, NULL for
699 * all others (might be needed later in IBSS)
700 */
701 struct ieee80211_if_ap *bss;
702
703 /* bitmap of allowed (non-MCS) rate indexes for rate control */
704 u32 rc_rateidx_mask[IEEE80211_NUM_BANDS];
705 u8 rc_rateidx_mcs_mask[IEEE80211_NUM_BANDS][IEEE80211_HT_MCS_MASK_LEN];
706
707 union {
708 struct ieee80211_if_ap ap;
709 struct ieee80211_if_wds wds;
710 struct ieee80211_if_vlan vlan;
711 struct ieee80211_if_managed mgd;
712 struct ieee80211_if_ibss ibss;
713 struct ieee80211_if_mesh mesh;
714 u32 mntr_flags;
715 } u;
716
717#ifdef CONFIG_MAC80211_DEBUGFS
718 struct {
719 struct dentry *dir;
720 struct dentry *subdir_stations;
721 struct dentry *default_unicast_key;
722 struct dentry *default_multicast_key;
723 struct dentry *default_mgmt_key;
724 } debugfs;
725#endif
726 /* must be last, dynamically sized area in this! */
727 struct ieee80211_vif vif;
728};
729
730static inline
731struct ieee80211_sub_if_data *vif_to_sdata(struct ieee80211_vif *p)
732{
733 return container_of(p, struct ieee80211_sub_if_data, vif);
734}
735
736enum sdata_queue_type {
737 IEEE80211_SDATA_QUEUE_TYPE_FRAME = 0,
738 IEEE80211_SDATA_QUEUE_AGG_START = 1,
739 IEEE80211_SDATA_QUEUE_AGG_STOP = 2,
740};
741
742enum {
743 IEEE80211_RX_MSG = 1,
744 IEEE80211_TX_STATUS_MSG = 2,
745 IEEE80211_EOSP_MSG = 3,
746};
747
748struct skb_eosp_msg_data {
749 u8 sta[ETH_ALEN], iface[ETH_ALEN];
750};
751
752enum queue_stop_reason {
753 IEEE80211_QUEUE_STOP_REASON_DRIVER,
754 IEEE80211_QUEUE_STOP_REASON_PS,
755 IEEE80211_QUEUE_STOP_REASON_CSA,
756 IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
757 IEEE80211_QUEUE_STOP_REASON_SUSPEND,
758 IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
759};
760
761#ifdef CONFIG_MAC80211_LEDS
762struct tpt_led_trigger {
763 struct led_trigger trig;
764 char name[32];
765 const struct ieee80211_tpt_blink *blink_table;
766 unsigned int blink_table_len;
767 struct timer_list timer;
768 unsigned long prev_traffic;
769 unsigned long tx_bytes, rx_bytes;
770 unsigned int active, want;
771 bool running;
772};
773#endif
774
775/**
776 * mac80211 scan flags - currently active scan mode
777 *
778 * @SCAN_SW_SCANNING: We're currently in the process of scanning but may as
779 * well be on the operating channel
780 * @SCAN_HW_SCANNING: The hardware is scanning for us, we have no way to
781 * determine if we are on the operating channel or not
782 * @SCAN_ONCHANNEL_SCANNING: Do a software scan on only the current operating
783 * channel. This should not interrupt normal traffic.
784 * @SCAN_COMPLETED: Set for our scan work function when the driver reported
785 * that the scan completed.
786 * @SCAN_ABORTED: Set for our scan work function when the driver reported
787 * a scan complete for an aborted scan.
788 */
789enum {
790 SCAN_SW_SCANNING,
791 SCAN_HW_SCANNING,
792 SCAN_ONCHANNEL_SCANNING,
793 SCAN_COMPLETED,
794 SCAN_ABORTED,
795};
796
797/**
798 * enum mac80211_scan_state - scan state machine states
799 *
800 * @SCAN_DECISION: Main entry point to the scan state machine, this state
801 * determines if we should keep on scanning or switch back to the
802 * operating channel
803 * @SCAN_SET_CHANNEL: Set the next channel to be scanned
804 * @SCAN_SEND_PROBE: Send probe requests and wait for probe responses
805 * @SCAN_SUSPEND: Suspend the scan and go back to operating channel to
806 * send out data
807 * @SCAN_RESUME: Resume the scan and scan the next channel
808 */
809enum mac80211_scan_state {
810 SCAN_DECISION,
811 SCAN_SET_CHANNEL,
812 SCAN_SEND_PROBE,
813 SCAN_SUSPEND,
814 SCAN_RESUME,
815};
816
817struct ieee80211_local {
818 /* embed the driver visible part.
819 * don't cast (use the static inlines below), but we keep
820 * it first anyway so they become a no-op */
821 struct ieee80211_hw hw;
822
823 const struct ieee80211_ops *ops;
824
825 /*
826 * private workqueue to mac80211. mac80211 makes this accessible
827 * via ieee80211_queue_work()
828 */
829 struct workqueue_struct *workqueue;
830
831 unsigned long queue_stop_reasons[IEEE80211_MAX_QUEUES];
832 /* also used to protect ampdu_ac_queue and amdpu_ac_stop_refcnt */
833 spinlock_t queue_stop_reason_lock;
834
835 int open_count;
836 int monitors, cooked_mntrs;
837 /* number of interfaces with corresponding FIF_ flags */
838 int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss, fif_pspoll,
839 fif_probe_req;
840 int probe_req_reg;
841 unsigned int filter_flags; /* FIF_* */
842
843 bool wiphy_ciphers_allocated;
844
845 /* protects the aggregated multicast list and filter calls */
846 spinlock_t filter_lock;
847
848 /* used for uploading changed mc list */
849 struct work_struct reconfig_filter;
850
851 /* used to reconfigure hardware SM PS */
852 struct work_struct recalc_smps;
853
854 /* aggregated multicast list */
855 struct netdev_hw_addr_list mc_list;
856
857 bool tim_in_locked_section; /* see ieee80211_beacon_get() */
858
859 /*
860 * suspended is true if we finished all the suspend _and_ we have
861 * not yet come up from resume. This is to be used by mac80211
862 * to ensure driver sanity during suspend and mac80211's own
863 * sanity. It can eventually be used for WoW as well.
864 */
865 bool suspended;
866
867 /*
868 * Resuming is true while suspended, but when we're reprogramming the
869 * hardware -- at that time it's allowed to use ieee80211_queue_work()
870 * again even though some other parts of the stack are still suspended
871 * and we still drop received frames to avoid waking the stack.
872 */
873 bool resuming;
874
875 /*
876 * quiescing is true during the suspend process _only_ to
877 * ease timer cancelling etc.
878 */
879 bool quiescing;
880
881 /* device is started */
882 bool started;
883
884 /* device is during a HW reconfig */
885 bool in_reconfig;
886
887 /* wowlan is enabled -- don't reconfig on resume */
888 bool wowlan;
889
890 int tx_headroom; /* required headroom for hardware/radiotap */
891
892 /* Tasklet and skb queue to process calls from IRQ mode. All frames
893 * added to skb_queue will be processed, but frames in
894 * skb_queue_unreliable may be dropped if the total length of these
895 * queues increases over the limit. */
896#define IEEE80211_IRQSAFE_QUEUE_LIMIT 128
897 struct tasklet_struct tasklet;
898 struct sk_buff_head skb_queue;
899 struct sk_buff_head skb_queue_unreliable;
900
901 /*
902 * Internal FIFO queue which is shared between multiple rx path
903 * stages. Its main task is to provide a serialization mechanism,
904 * so all rx handlers can enjoy having exclusive access to their
905 * private data structures.
906 */
907 struct sk_buff_head rx_skb_queue;
908 bool running_rx_handler; /* protected by rx_skb_queue.lock */
909
910 /* Station data */
911 /*
912 * The mutex only protects the list, hash table and
913 * counter, reads are done with RCU.
914 */
915 struct mutex sta_mtx;
916 spinlock_t tim_lock;
917 unsigned long num_sta;
918 struct list_head sta_list;
919 struct sta_info __rcu *sta_hash[STA_HASH_SIZE];
920 struct timer_list sta_cleanup;
921 int sta_generation;
922
923 struct sk_buff_head pending[IEEE80211_MAX_QUEUES];
924 struct tasklet_struct tx_pending_tasklet;
925
926 atomic_t agg_queue_stop[IEEE80211_MAX_QUEUES];
927
928 /* number of interfaces with corresponding IFF_ flags */
929 atomic_t iff_allmultis, iff_promiscs;
930
931 struct rate_control_ref *rate_ctrl;
932
933 struct crypto_cipher *wep_tx_tfm;
934 struct crypto_cipher *wep_rx_tfm;
935 u32 wep_iv;
936
937 /* see iface.c */
938 struct list_head interfaces;
939 struct mutex iflist_mtx;
940
941 /*
942 * Key mutex, protects sdata's key_list and sta_info's
943 * key pointers (write access, they're RCU.)
944 */
945 struct mutex key_mtx;
946
947 /* mutex for scan and work locking */
948 struct mutex mtx;
949
950 /* Scanning and BSS list */
951 unsigned long scanning;
952 struct cfg80211_ssid scan_ssid;
953 struct cfg80211_scan_request *int_scan_req;
954 struct cfg80211_scan_request *scan_req, *hw_scan_req;
955 struct ieee80211_channel *scan_channel;
956 enum ieee80211_band hw_scan_band;
957 int scan_channel_idx;
958 int scan_ies_len;
959
960 bool sched_scanning;
961 struct ieee80211_sched_scan_ies sched_scan_ies;
962 struct work_struct sched_scan_stopped_work;
963
964 unsigned long leave_oper_channel_time;
965 enum mac80211_scan_state next_scan_state;
966 struct delayed_work scan_work;
967 struct ieee80211_sub_if_data *scan_sdata;
968 enum nl80211_channel_type _oper_channel_type;
969 struct ieee80211_channel *oper_channel, *csa_channel;
970
971 /* Temporary remain-on-channel for off-channel operations */
972 struct ieee80211_channel *tmp_channel;
973 enum nl80211_channel_type tmp_channel_type;
974
975 /* SNMP counters */
976 /* dot11CountersTable */
977 u32 dot11TransmittedFragmentCount;
978 u32 dot11MulticastTransmittedFrameCount;
979 u32 dot11FailedCount;
980 u32 dot11RetryCount;
981 u32 dot11MultipleRetryCount;
982 u32 dot11FrameDuplicateCount;
983 u32 dot11ReceivedFragmentCount;
984 u32 dot11MulticastReceivedFrameCount;
985 u32 dot11TransmittedFrameCount;
986
987#ifdef CONFIG_MAC80211_LEDS
988 int tx_led_counter, rx_led_counter;
989 struct led_trigger *tx_led, *rx_led, *assoc_led, *radio_led;
990 struct tpt_led_trigger *tpt_led_trigger;
991 char tx_led_name[32], rx_led_name[32],
992 assoc_led_name[32], radio_led_name[32];
993#endif
994
995#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
996 /* TX/RX handler statistics */
997 unsigned int tx_handlers_drop;
998 unsigned int tx_handlers_queued;
999 unsigned int tx_handlers_drop_unencrypted;
1000 unsigned int tx_handlers_drop_fragment;
1001 unsigned int tx_handlers_drop_wep;
1002 unsigned int tx_handlers_drop_not_assoc;
1003 unsigned int tx_handlers_drop_unauth_port;
1004 unsigned int rx_handlers_drop;
1005 unsigned int rx_handlers_queued;
1006 unsigned int rx_handlers_drop_nullfunc;
1007 unsigned int rx_handlers_drop_defrag;
1008 unsigned int rx_handlers_drop_short;
1009 unsigned int rx_handlers_drop_passive_scan;
1010 unsigned int tx_expand_skb_head;
1011 unsigned int tx_expand_skb_head_cloned;
1012 unsigned int rx_expand_skb_head;
1013 unsigned int rx_expand_skb_head2;
1014 unsigned int rx_handlers_fragments;
1015 unsigned int tx_status_drop;
1016#define I802_DEBUG_INC(c) (c)++
1017#else /* CONFIG_MAC80211_DEBUG_COUNTERS */
1018#define I802_DEBUG_INC(c) do { } while (0)
1019#endif /* CONFIG_MAC80211_DEBUG_COUNTERS */
1020
1021
1022 int total_ps_buffered; /* total number of all buffered unicast and
1023 * multicast packets for power saving stations
1024 */
1025 unsigned int wmm_acm; /* bit field of ACM bits (BIT(802.1D tag)) */
1026
1027 bool pspolling;
1028 bool offchannel_ps_enabled;
1029 /*
1030 * PS can only be enabled when we have exactly one managed
1031 * interface (and monitors) in PS, this then points there.
1032 */
1033 struct ieee80211_sub_if_data *ps_sdata;
1034 struct work_struct dynamic_ps_enable_work;
1035 struct work_struct dynamic_ps_disable_work;
1036 struct timer_list dynamic_ps_timer;
1037 struct notifier_block network_latency_notifier;
1038 struct notifier_block ifa_notifier;
1039
1040 /*
1041 * The dynamic ps timeout configured from user space via WEXT -
1042 * this will override whatever chosen by mac80211 internally.
1043 */
1044 int dynamic_ps_forced_timeout;
1045 int dynamic_ps_user_timeout;
1046 bool disable_dynamic_ps;
1047
1048 int user_power_level; /* in dBm */
1049 int power_constr_level; /* in dBm */
1050
1051 enum ieee80211_smps_mode smps_mode;
1052
1053 struct work_struct restart_work;
1054
1055#ifdef CONFIG_MAC80211_DEBUGFS
1056 struct local_debugfsdentries {
1057 struct dentry *rcdir;
1058 struct dentry *keys;
1059 } debugfs;
1060#endif
1061
1062 /*
1063 * Remain-on-channel support
1064 */
1065 struct list_head roc_list;
1066 struct work_struct hw_roc_start, hw_roc_done;
1067 unsigned long hw_roc_start_time;
1068
1069 struct idr ack_status_frames;
1070 spinlock_t ack_status_lock;
1071
1072 /* dummy netdev for use w/ NAPI */
1073 struct net_device napi_dev;
1074
1075 struct napi_struct napi;
1076
1077 /* virtual monitor interface */
1078 struct ieee80211_sub_if_data __rcu *monitor_sdata;
1079};
1080
1081static inline struct ieee80211_sub_if_data *
1082IEEE80211_DEV_TO_SUB_IF(struct net_device *dev)
1083{
1084 return netdev_priv(dev);
1085}
1086
1087/* this struct represents 802.11n's RA/TID combination */
1088struct ieee80211_ra_tid {
1089 u8 ra[ETH_ALEN];
1090 u16 tid;
1091};
1092
1093/* Parsed Information Elements */
1094struct ieee802_11_elems {
1095 u8 *ie_start;
1096 size_t total_len;
1097
1098 /* pointers to IEs */
1099 u8 *ssid;
1100 u8 *supp_rates;
1101 u8 *fh_params;
1102 u8 *ds_params;
1103 u8 *cf_params;
1104 struct ieee80211_tim_ie *tim;
1105 u8 *ibss_params;
1106 u8 *challenge;
1107 u8 *wpa;
1108 u8 *rsn;
1109 u8 *erp_info;
1110 u8 *ext_supp_rates;
1111 u8 *wmm_info;
1112 u8 *wmm_param;
1113 struct ieee80211_ht_cap *ht_cap_elem;
1114 struct ieee80211_ht_operation *ht_operation;
1115 struct ieee80211_meshconf_ie *mesh_config;
1116 u8 *mesh_id;
1117 u8 *peering;
1118 u8 *preq;
1119 u8 *prep;
1120 u8 *perr;
1121 struct ieee80211_rann_ie *rann;
1122 u8 *ch_switch_elem;
1123 u8 *country_elem;
1124 u8 *pwr_constr_elem;
1125 u8 *quiet_elem; /* first quite element */
1126 u8 *timeout_int;
1127
1128 /* length of them, respectively */
1129 u8 ssid_len;
1130 u8 supp_rates_len;
1131 u8 fh_params_len;
1132 u8 ds_params_len;
1133 u8 cf_params_len;
1134 u8 tim_len;
1135 u8 ibss_params_len;
1136 u8 challenge_len;
1137 u8 wpa_len;
1138 u8 rsn_len;
1139 u8 erp_info_len;
1140 u8 ext_supp_rates_len;
1141 u8 wmm_info_len;
1142 u8 wmm_param_len;
1143 u8 mesh_id_len;
1144 u8 peering_len;
1145 u8 preq_len;
1146 u8 prep_len;
1147 u8 perr_len;
1148 u8 ch_switch_elem_len;
1149 u8 country_elem_len;
1150 u8 pwr_constr_elem_len;
1151 u8 quiet_elem_len;
1152 u8 num_of_quiet_elem; /* can be more the one */
1153 u8 timeout_int_len;
1154
1155 /* whether a parse error occurred while retrieving these elements */
1156 bool parse_error;
1157};
1158
1159static inline struct ieee80211_local *hw_to_local(
1160 struct ieee80211_hw *hw)
1161{
1162 return container_of(hw, struct ieee80211_local, hw);
1163}
1164
1165
1166static inline int ieee80211_bssid_match(const u8 *raddr, const u8 *addr)
1167{
1168 return ether_addr_equal(raddr, addr) ||
1169 is_broadcast_ether_addr(raddr);
1170}
1171
1172
1173int ieee80211_hw_config(struct ieee80211_local *local, u32 changed);
1174void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx);
1175void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
1176 u32 changed);
1177void ieee80211_configure_filter(struct ieee80211_local *local);
1178u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata);
1179
1180/* STA code */
1181void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata);
1182int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
1183 struct cfg80211_auth_request *req);
1184int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
1185 struct cfg80211_assoc_request *req);
1186int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
1187 struct cfg80211_deauth_request *req);
1188int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
1189 struct cfg80211_disassoc_request *req);
1190void ieee80211_send_pspoll(struct ieee80211_local *local,
1191 struct ieee80211_sub_if_data *sdata);
1192void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency);
1193int ieee80211_max_network_latency(struct notifier_block *nb,
1194 unsigned long data, void *dummy);
1195int ieee80211_set_arp_filter(struct ieee80211_sub_if_data *sdata);
1196void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
1197 struct ieee80211_channel_sw_ie *sw_elem,
1198 struct ieee80211_bss *bss,
1199 u64 timestamp);
1200void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata);
1201void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata);
1202void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata);
1203void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
1204 struct sk_buff *skb);
1205void ieee80211_sta_reset_beacon_monitor(struct ieee80211_sub_if_data *sdata);
1206void ieee80211_sta_reset_conn_monitor(struct ieee80211_sub_if_data *sdata);
1207void ieee80211_mgd_stop(struct ieee80211_sub_if_data *sdata);
1208
1209/* IBSS code */
1210void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local);
1211void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata);
1212void ieee80211_ibss_rx_no_sta(struct ieee80211_sub_if_data *sdata,
1213 const u8 *bssid, const u8 *addr, u32 supp_rates);
1214int ieee80211_ibss_join(struct ieee80211_sub_if_data *sdata,
1215 struct cfg80211_ibss_params *params);
1216int ieee80211_ibss_leave(struct ieee80211_sub_if_data *sdata);
1217void ieee80211_ibss_quiesce(struct ieee80211_sub_if_data *sdata);
1218void ieee80211_ibss_restart(struct ieee80211_sub_if_data *sdata);
1219void ieee80211_ibss_work(struct ieee80211_sub_if_data *sdata);
1220void ieee80211_ibss_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
1221 struct sk_buff *skb);
1222
1223/* mesh code */
1224void ieee80211_mesh_work(struct ieee80211_sub_if_data *sdata);
1225void ieee80211_mesh_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
1226 struct sk_buff *skb);
1227
1228/* scan/BSS handling */
1229void ieee80211_scan_work(struct work_struct *work);
1230int ieee80211_request_internal_scan(struct ieee80211_sub_if_data *sdata,
1231 const u8 *ssid, u8 ssid_len,
1232 struct ieee80211_channel *chan);
1233int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
1234 struct cfg80211_scan_request *req);
1235void ieee80211_scan_cancel(struct ieee80211_local *local);
1236void ieee80211_run_deferred_scan(struct ieee80211_local *local);
1237ieee80211_rx_result
1238ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb);
1239
1240void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local);
1241struct ieee80211_bss *
1242ieee80211_bss_info_update(struct ieee80211_local *local,
1243 struct ieee80211_rx_status *rx_status,
1244 struct ieee80211_mgmt *mgmt,
1245 size_t len,
1246 struct ieee802_11_elems *elems,
1247 struct ieee80211_channel *channel,
1248 bool beacon);
1249void ieee80211_rx_bss_put(struct ieee80211_local *local,
1250 struct ieee80211_bss *bss);
1251
1252/* scheduled scan handling */
1253int ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
1254 struct cfg80211_sched_scan_request *req);
1255int ieee80211_request_sched_scan_stop(struct ieee80211_sub_if_data *sdata);
1256void ieee80211_sched_scan_stopped_work(struct work_struct *work);
1257
1258/* off-channel helpers */
1259void ieee80211_offchannel_stop_vifs(struct ieee80211_local *local,
1260 bool offchannel_ps_enable);
1261void ieee80211_offchannel_return(struct ieee80211_local *local,
1262 bool offchannel_ps_disable);
1263void ieee80211_roc_setup(struct ieee80211_local *local);
1264void ieee80211_start_next_roc(struct ieee80211_local *local);
1265void ieee80211_roc_purge(struct ieee80211_sub_if_data *sdata);
1266void ieee80211_roc_notify_destroy(struct ieee80211_roc_work *roc);
1267void ieee80211_sw_roc_work(struct work_struct *work);
1268void ieee80211_handle_roc_started(struct ieee80211_roc_work *roc);
1269
1270/* interface handling */
1271int ieee80211_iface_init(void);
1272void ieee80211_iface_exit(void);
1273int ieee80211_if_add(struct ieee80211_local *local, const char *name,
1274 struct net_device **new_dev, enum nl80211_iftype type,
1275 struct vif_params *params);
1276int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
1277 enum nl80211_iftype type);
1278void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata);
1279void ieee80211_remove_interfaces(struct ieee80211_local *local);
1280u32 __ieee80211_recalc_idle(struct ieee80211_local *local);
1281void ieee80211_recalc_idle(struct ieee80211_local *local);
1282void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
1283 const int offset);
1284
1285static inline bool ieee80211_sdata_running(struct ieee80211_sub_if_data *sdata)
1286{
1287 return test_bit(SDATA_STATE_RUNNING, &sdata->state);
1288}
1289
1290/* tx handling */
1291void ieee80211_clear_tx_pending(struct ieee80211_local *local);
1292void ieee80211_tx_pending(unsigned long data);
1293netdev_tx_t ieee80211_monitor_start_xmit(struct sk_buff *skb,
1294 struct net_device *dev);
1295netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb,
1296 struct net_device *dev);
1297
1298/* HT */
1299void ieee80211_apply_htcap_overrides(struct ieee80211_sub_if_data *sdata,
1300 struct ieee80211_sta_ht_cap *ht_cap);
1301void ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_sub_if_data *sdata,
1302 struct ieee80211_supported_band *sband,
1303 struct ieee80211_ht_cap *ht_cap_ie,
1304 struct ieee80211_sta_ht_cap *ht_cap);
1305void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata,
1306 const u8 *da, u16 tid,
1307 u16 initiator, u16 reason_code);
1308int ieee80211_send_smps_action(struct ieee80211_sub_if_data *sdata,
1309 enum ieee80211_smps_mode smps, const u8 *da,
1310 const u8 *bssid);
1311void ieee80211_request_smps_work(struct work_struct *work);
1312
1313void ___ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
1314 u16 initiator, u16 reason, bool stop);
1315void __ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
1316 u16 initiator, u16 reason, bool stop);
1317void ieee80211_sta_tear_down_BA_sessions(struct sta_info *sta, bool tx);
1318void ieee80211_process_delba(struct ieee80211_sub_if_data *sdata,
1319 struct sta_info *sta,
1320 struct ieee80211_mgmt *mgmt, size_t len);
1321void ieee80211_process_addba_resp(struct ieee80211_local *local,
1322 struct sta_info *sta,
1323 struct ieee80211_mgmt *mgmt,
1324 size_t len);
1325void ieee80211_process_addba_request(struct ieee80211_local *local,
1326 struct sta_info *sta,
1327 struct ieee80211_mgmt *mgmt,
1328 size_t len);
1329
1330int __ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
1331 enum ieee80211_back_parties initiator,
1332 bool tx);
1333int ___ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
1334 enum ieee80211_back_parties initiator,
1335 bool tx);
1336void ieee80211_start_tx_ba_cb(struct ieee80211_vif *vif, u8 *ra, u16 tid);
1337void ieee80211_stop_tx_ba_cb(struct ieee80211_vif *vif, u8 *ra, u8 tid);
1338void ieee80211_ba_session_work(struct work_struct *work);
1339void ieee80211_tx_ba_session_handle_start(struct sta_info *sta, int tid);
1340void ieee80211_release_reorder_timeout(struct sta_info *sta, int tid);
1341
1342/* Spectrum management */
1343void ieee80211_process_measurement_req(struct ieee80211_sub_if_data *sdata,
1344 struct ieee80211_mgmt *mgmt,
1345 size_t len);
1346
1347/* Suspend/resume and hw reconfiguration */
1348int ieee80211_reconfig(struct ieee80211_local *local);
1349void ieee80211_stop_device(struct ieee80211_local *local);
1350
1351#ifdef CONFIG_PM
1352int __ieee80211_suspend(struct ieee80211_hw *hw,
1353 struct cfg80211_wowlan *wowlan);
1354
1355static inline int __ieee80211_resume(struct ieee80211_hw *hw)
1356{
1357 struct ieee80211_local *local = hw_to_local(hw);
1358
1359 WARN(test_bit(SCAN_HW_SCANNING, &local->scanning),
1360 "%s: resume with hardware scan still in progress\n",
1361 wiphy_name(hw->wiphy));
1362
1363 return ieee80211_reconfig(hw_to_local(hw));
1364}
1365#else
1366static inline int __ieee80211_suspend(struct ieee80211_hw *hw,
1367 struct cfg80211_wowlan *wowlan)
1368{
1369 return 0;
1370}
1371
1372static inline int __ieee80211_resume(struct ieee80211_hw *hw)
1373{
1374 return 0;
1375}
1376#endif
1377
1378/* utility functions/constants */
1379extern void *mac80211_wiphy_privid; /* for wiphy privid */
1380u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
1381 enum nl80211_iftype type);
1382int ieee80211_frame_duration(enum ieee80211_band band, size_t len,
1383 int rate, int erp, int short_preamble);
1384void mac80211_ev_michael_mic_failure(struct ieee80211_sub_if_data *sdata, int keyidx,
1385 struct ieee80211_hdr *hdr, const u8 *tsc,
1386 gfp_t gfp);
1387void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
1388 bool bss_notify);
1389void ieee80211_xmit(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb);
1390
1391void ieee80211_tx_skb_tid(struct ieee80211_sub_if_data *sdata,
1392 struct sk_buff *skb, int tid);
1393static void inline ieee80211_tx_skb(struct ieee80211_sub_if_data *sdata,
1394 struct sk_buff *skb)
1395{
1396 /* Send all internal mgmt frames on VO. Accordingly set TID to 7. */
1397 ieee80211_tx_skb_tid(sdata, skb, 7);
1398}
1399
1400void ieee802_11_parse_elems(u8 *start, size_t len,
1401 struct ieee802_11_elems *elems);
1402u32 ieee802_11_parse_elems_crc(u8 *start, size_t len,
1403 struct ieee802_11_elems *elems,
1404 u64 filter, u32 crc);
1405u32 ieee80211_mandatory_rates(struct ieee80211_local *local,
1406 enum ieee80211_band band);
1407
1408void ieee80211_dynamic_ps_enable_work(struct work_struct *work);
1409void ieee80211_dynamic_ps_disable_work(struct work_struct *work);
1410void ieee80211_dynamic_ps_timer(unsigned long data);
1411void ieee80211_send_nullfunc(struct ieee80211_local *local,
1412 struct ieee80211_sub_if_data *sdata,
1413 int powersave);
1414void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
1415 struct ieee80211_hdr *hdr);
1416void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata,
1417 struct ieee80211_hdr *hdr, bool ack);
1418void ieee80211_beacon_connection_loss_work(struct work_struct *work);
1419
1420void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
1421 enum queue_stop_reason reason);
1422void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
1423 enum queue_stop_reason reason);
1424void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
1425 enum queue_stop_reason reason);
1426void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
1427 enum queue_stop_reason reason);
1428void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue);
1429void ieee80211_add_pending_skb(struct ieee80211_local *local,
1430 struct sk_buff *skb);
1431void ieee80211_add_pending_skbs_fn(struct ieee80211_local *local,
1432 struct sk_buff_head *skbs,
1433 void (*fn)(void *data), void *data);
1434static inline void ieee80211_add_pending_skbs(struct ieee80211_local *local,
1435 struct sk_buff_head *skbs)
1436{
1437 ieee80211_add_pending_skbs_fn(local, skbs, NULL, NULL);
1438}
1439
1440void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
1441 u16 transaction, u16 auth_alg,
1442 u8 *extra, size_t extra_len, const u8 *bssid,
1443 const u8 *da, const u8 *key, u8 key_len, u8 key_idx);
1444int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
1445 const u8 *ie, size_t ie_len,
1446 enum ieee80211_band band, u32 rate_mask,
1447 u8 channel);
1448struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
1449 u8 *dst, u32 ratemask,
1450 const u8 *ssid, size_t ssid_len,
1451 const u8 *ie, size_t ie_len,
1452 bool directed);
1453void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
1454 const u8 *ssid, size_t ssid_len,
1455 const u8 *ie, size_t ie_len,
1456 u32 ratemask, bool directed, bool no_cck);
1457
1458void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata,
1459 const size_t supp_rates_len,
1460 const u8 *supp_rates);
1461u32 ieee80211_sta_get_rates(struct ieee80211_local *local,
1462 struct ieee802_11_elems *elems,
1463 enum ieee80211_band band, u32 *basic_rates);
1464int __ieee80211_request_smps(struct ieee80211_sub_if_data *sdata,
1465 enum ieee80211_smps_mode smps_mode);
1466void ieee80211_recalc_smps(struct ieee80211_local *local);
1467
1468size_t ieee80211_ie_split(const u8 *ies, size_t ielen,
1469 const u8 *ids, int n_ids, size_t offset);
1470size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset);
1471u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
1472 u16 cap);
1473u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
1474 struct ieee80211_channel *channel,
1475 enum nl80211_channel_type channel_type,
1476 u16 prot_mode);
1477
1478/* channel management */
1479enum ieee80211_chan_mode {
1480 CHAN_MODE_UNDEFINED,
1481 CHAN_MODE_HOPPING,
1482 CHAN_MODE_FIXED,
1483};
1484
1485enum ieee80211_chan_mode
1486ieee80211_get_channel_mode(struct ieee80211_local *local,
1487 struct ieee80211_sub_if_data *ignore);
1488bool ieee80211_set_channel_type(struct ieee80211_local *local,
1489 struct ieee80211_sub_if_data *sdata,
1490 enum nl80211_channel_type chantype);
1491enum nl80211_channel_type
1492ieee80211_ht_oper_to_channel_type(struct ieee80211_ht_operation *ht_oper);
1493
1494#ifdef CONFIG_MAC80211_NOINLINE
1495#define debug_noinline noinline
1496#else
1497#define debug_noinline
1498#endif
1499
1500#endif /* IEEE80211_I_H */
Ubuntu Artful kernel mirror