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-2008 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 <net/cfg80211.h> 27 #include <net/mac80211.h> 28 #include "key.h" 29 #include "sta_info.h" 30 31 struct ieee80211_local; 32 33 /* Maximum number of broadcast/multicast frames to buffer when some of the 34 * associated stations are using power saving. */ 35 #define AP_MAX_BC_BUFFER 128 36 37 /* Maximum number of frames buffered to all STAs, including multicast frames. 38 * Note: increasing this limit increases the potential memory requirement. Each 39 * frame can be up to about 2 kB long. */ 40 #define TOTAL_MAX_TX_BUFFER 512 41 42 /* Required encryption head and tailroom */ 43 #define IEEE80211_ENCRYPT_HEADROOM 8 44 #define IEEE80211_ENCRYPT_TAILROOM 18 45 46 /* IEEE 802.11 (Ch. 9.5 Defragmentation) requires support for concurrent 47 * reception of at least three fragmented frames. This limit can be increased 48 * by changing this define, at the cost of slower frame reassembly and 49 * increased memory use (about 2 kB of RAM per entry). */ 50 #define IEEE80211_FRAGMENT_MAX 4 51 52 /* 53 * Time after which we ignore scan results and no longer report/use 54 * them in any way. 55 */ 56 #define IEEE80211_SCAN_RESULT_EXPIRE (10 * HZ) 57 58 #define TU_TO_EXP_TIME(x) (jiffies + usecs_to_jiffies((x) * 1024)) 59 60 struct ieee80211_fragment_entry { 61 unsigned long first_frag_time; 62 unsigned int seq; 63 unsigned int rx_queue; 64 unsigned int last_frag; 65 unsigned int extra_len; 66 struct sk_buff_head skb_list; 67 int ccmp; /* Whether fragments were encrypted with CCMP */ 68 u8 last_pn[6]; /* PN of the last fragment if CCMP was used */ 69 }; 70 71 72 struct ieee80211_bss { 73 /* Yes, this is a hack */ 74 struct cfg80211_bss cbss; 75 76 /* don't want to look up all the time */ 77 size_t ssid_len; 78 u8 ssid[IEEE80211_MAX_SSID_LEN]; 79 80 u8 dtim_period; 81 82 bool wmm_used; 83 84 unsigned long last_probe_resp; 85 86 #ifdef CONFIG_MAC80211_MESH 87 u8 *mesh_id; 88 size_t mesh_id_len; 89 u8 *mesh_cfg; 90 #endif 91 92 #define IEEE80211_MAX_SUPP_RATES 32 93 u8 supp_rates[IEEE80211_MAX_SUPP_RATES]; 94 size_t supp_rates_len; 95 96 /* 97 * During assocation, we save an ERP value from a probe response so 98 * that we can feed ERP info to the driver when handling the 99 * association completes. these fields probably won't be up-to-date 100 * otherwise, you probably don't want to use them. 101 */ 102 bool has_erp_value; 103 u8 erp_value; 104 }; 105 106 static inline u8 *bss_mesh_cfg(struct ieee80211_bss *bss) 107 { 108 #ifdef CONFIG_MAC80211_MESH 109 return bss->mesh_cfg; 110 #endif 111 return NULL; 112 } 113 114 static inline u8 *bss_mesh_id(struct ieee80211_bss *bss) 115 { 116 #ifdef CONFIG_MAC80211_MESH 117 return bss->mesh_id; 118 #endif 119 return NULL; 120 } 121 122 static inline u8 bss_mesh_id_len(struct ieee80211_bss *bss) 123 { 124 #ifdef CONFIG_MAC80211_MESH 125 return bss->mesh_id_len; 126 #endif 127 return 0; 128 } 129 130 131 typedef unsigned __bitwise__ ieee80211_tx_result; 132 #define TX_CONTINUE ((__force ieee80211_tx_result) 0u) 133 #define TX_DROP ((__force ieee80211_tx_result) 1u) 134 #define TX_QUEUED ((__force ieee80211_tx_result) 2u) 135 136 #define IEEE80211_TX_FRAGMENTED BIT(0) 137 #define IEEE80211_TX_UNICAST BIT(1) 138 #define IEEE80211_TX_PS_BUFFERED BIT(2) 139 140 struct ieee80211_tx_data { 141 struct sk_buff *skb; 142 struct net_device *dev; 143 struct ieee80211_local *local; 144 struct ieee80211_sub_if_data *sdata; 145 struct sta_info *sta; 146 struct ieee80211_key *key; 147 148 struct ieee80211_channel *channel; 149 150 u16 ethertype; 151 unsigned int flags; 152 }; 153 154 155 typedef unsigned __bitwise__ ieee80211_rx_result; 156 #define RX_CONTINUE ((__force ieee80211_rx_result) 0u) 157 #define RX_DROP_UNUSABLE ((__force ieee80211_rx_result) 1u) 158 #define RX_DROP_MONITOR ((__force ieee80211_rx_result) 2u) 159 #define RX_QUEUED ((__force ieee80211_rx_result) 3u) 160 161 #define IEEE80211_RX_IN_SCAN BIT(0) 162 /* frame is destined to interface currently processed (incl. multicast frames) */ 163 #define IEEE80211_RX_RA_MATCH BIT(1) 164 #define IEEE80211_RX_AMSDU BIT(2) 165 #define IEEE80211_RX_CMNTR_REPORTED BIT(3) 166 #define IEEE80211_RX_FRAGMENTED BIT(4) 167 168 struct ieee80211_rx_data { 169 struct sk_buff *skb; 170 struct net_device *dev; 171 struct ieee80211_local *local; 172 struct ieee80211_sub_if_data *sdata; 173 struct sta_info *sta; 174 struct ieee80211_key *key; 175 struct ieee80211_rx_status *status; 176 struct ieee80211_rate *rate; 177 178 unsigned int flags; 179 int sent_ps_buffered; 180 int queue; 181 u32 tkip_iv32; 182 u16 tkip_iv16; 183 }; 184 185 struct beacon_data { 186 u8 *head, *tail; 187 int head_len, tail_len; 188 int dtim_period; 189 }; 190 191 struct ieee80211_if_ap { 192 struct beacon_data *beacon; 193 194 struct list_head vlans; 195 196 /* yes, this looks ugly, but guarantees that we can later use 197 * bitmap_empty :) 198 * NB: don't touch this bitmap, use sta_info_{set,clear}_tim_bit */ 199 u8 tim[sizeof(unsigned long) * BITS_TO_LONGS(IEEE80211_MAX_AID + 1)]; 200 struct sk_buff_head ps_bc_buf; 201 atomic_t num_sta_ps; /* number of stations in PS mode */ 202 int dtim_count; 203 }; 204 205 struct ieee80211_if_wds { 206 struct sta_info *sta; 207 u8 remote_addr[ETH_ALEN]; 208 }; 209 210 struct ieee80211_if_vlan { 211 struct list_head list; 212 }; 213 214 struct mesh_stats { 215 __u32 fwded_frames; /* Mesh forwarded frames */ 216 __u32 dropped_frames_ttl; /* Not transmitted since mesh_ttl == 0*/ 217 __u32 dropped_frames_no_route; /* Not transmitted, no route found */ 218 atomic_t estab_plinks; 219 }; 220 221 #define PREQ_Q_F_START 0x1 222 #define PREQ_Q_F_REFRESH 0x2 223 struct mesh_preq_queue { 224 struct list_head list; 225 u8 dst[ETH_ALEN]; 226 u8 flags; 227 }; 228 229 enum ieee80211_mgd_state { 230 IEEE80211_MGD_STATE_IDLE, 231 IEEE80211_MGD_STATE_PROBE, 232 IEEE80211_MGD_STATE_AUTH, 233 IEEE80211_MGD_STATE_ASSOC, 234 }; 235 236 struct ieee80211_mgd_work { 237 struct list_head list; 238 struct ieee80211_bss *bss; 239 int ie_len; 240 u8 prev_bssid[ETH_ALEN]; 241 u8 ssid[IEEE80211_MAX_SSID_LEN]; 242 u8 ssid_len; 243 unsigned long timeout; 244 enum ieee80211_mgd_state state; 245 u16 auth_alg, auth_transaction; 246 247 int tries; 248 249 u8 key[WLAN_KEY_LEN_WEP104]; 250 u8 key_len, key_idx; 251 252 /* must be last */ 253 u8 ie[0]; /* for auth or assoc frame, not probe */ 254 }; 255 256 /* flags used in struct ieee80211_if_managed.flags */ 257 enum ieee80211_sta_flags { 258 IEEE80211_STA_BEACON_POLL = BIT(0), 259 IEEE80211_STA_CONNECTION_POLL = BIT(1), 260 IEEE80211_STA_CONTROL_PORT = BIT(2), 261 IEEE80211_STA_WMM_ENABLED = BIT(3), 262 IEEE80211_STA_DISABLE_11N = BIT(4), 263 IEEE80211_STA_CSA_RECEIVED = BIT(5), 264 IEEE80211_STA_MFP_ENABLED = BIT(6), 265 }; 266 267 /* flags for MLME request */ 268 enum ieee80211_sta_request { 269 IEEE80211_STA_REQ_SCAN, 270 }; 271 272 struct ieee80211_if_managed { 273 struct timer_list timer; 274 struct timer_list conn_mon_timer; 275 struct timer_list bcn_mon_timer; 276 struct timer_list chswitch_timer; 277 struct work_struct work; 278 struct work_struct monitor_work; 279 struct work_struct chswitch_work; 280 struct work_struct beacon_loss_work; 281 282 unsigned long probe_timeout; 283 284 struct mutex mtx; 285 struct ieee80211_bss *associated; 286 struct list_head work_list; 287 288 u8 bssid[ETH_ALEN]; 289 290 u16 aid; 291 u16 capab; 292 293 struct sk_buff_head skb_queue; 294 295 unsigned long timers_running; /* used for quiesce/restart */ 296 bool powersave; /* powersave requested for this iface */ 297 298 unsigned long request; 299 300 unsigned int flags; 301 302 u32 beacon_crc; 303 304 enum { 305 IEEE80211_MFP_DISABLED, 306 IEEE80211_MFP_OPTIONAL, 307 IEEE80211_MFP_REQUIRED 308 } mfp; /* management frame protection */ 309 310 int wmm_last_param_set; 311 }; 312 313 enum ieee80211_ibss_request { 314 IEEE80211_IBSS_REQ_RUN = 0, 315 }; 316 317 struct ieee80211_if_ibss { 318 struct timer_list timer; 319 struct work_struct work; 320 321 struct sk_buff_head skb_queue; 322 323 unsigned long request; 324 unsigned long last_scan_completed; 325 326 bool timer_running; 327 328 bool fixed_bssid; 329 bool fixed_channel; 330 bool privacy; 331 332 u8 bssid[ETH_ALEN]; 333 u8 ssid[IEEE80211_MAX_SSID_LEN]; 334 u8 ssid_len, ie_len; 335 u8 *ie; 336 struct ieee80211_channel *channel; 337 338 unsigned long ibss_join_req; 339 /* probe response/beacon for IBSS */ 340 struct sk_buff *presp, *skb; 341 342 enum { 343 IEEE80211_IBSS_MLME_SEARCH, 344 IEEE80211_IBSS_MLME_JOINED, 345 } state; 346 }; 347 348 struct ieee80211_if_mesh { 349 struct work_struct work; 350 struct timer_list housekeeping_timer; 351 struct timer_list mesh_path_timer; 352 struct sk_buff_head skb_queue; 353 354 unsigned long timers_running; 355 356 bool housekeeping; 357 358 u8 mesh_id[IEEE80211_MAX_MESH_ID_LEN]; 359 size_t mesh_id_len; 360 /* Active Path Selection Protocol Identifier */ 361 u8 mesh_pp_id[4]; 362 /* Active Path Selection Metric Identifier */ 363 u8 mesh_pm_id[4]; 364 /* Congestion Control Mode Identifier */ 365 u8 mesh_cc_id[4]; 366 /* Local mesh Destination Sequence Number */ 367 u32 dsn; 368 /* Last used PREQ ID */ 369 u32 preq_id; 370 atomic_t mpaths; 371 /* Timestamp of last DSN update */ 372 unsigned long last_dsn_update; 373 /* Timestamp of last DSN sent */ 374 unsigned long last_preq; 375 struct mesh_rmc *rmc; 376 spinlock_t mesh_preq_queue_lock; 377 struct mesh_preq_queue preq_queue; 378 int preq_queue_len; 379 struct mesh_stats mshstats; 380 struct mesh_config mshcfg; 381 u32 mesh_seqnum; 382 bool accepting_plinks; 383 }; 384 385 #ifdef CONFIG_MAC80211_MESH 386 #define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \ 387 do { (msh)->mshstats.name++; } while (0) 388 #else 389 #define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \ 390 do { } while (0) 391 #endif 392 393 /** 394 * enum ieee80211_sub_if_data_flags - virtual interface flags 395 * 396 * @IEEE80211_SDATA_ALLMULTI: interface wants all multicast packets 397 * @IEEE80211_SDATA_PROMISC: interface is promisc 398 * @IEEE80211_SDATA_OPERATING_GMODE: operating in G-only mode 399 * @IEEE80211_SDATA_DONT_BRIDGE_PACKETS: bridge packets between 400 * associated stations and deliver multicast frames both 401 * back to wireless media and to the local net stack. 402 */ 403 enum ieee80211_sub_if_data_flags { 404 IEEE80211_SDATA_ALLMULTI = BIT(0), 405 IEEE80211_SDATA_PROMISC = BIT(1), 406 IEEE80211_SDATA_OPERATING_GMODE = BIT(2), 407 IEEE80211_SDATA_DONT_BRIDGE_PACKETS = BIT(3), 408 }; 409 410 struct ieee80211_sub_if_data { 411 struct list_head list; 412 413 struct wireless_dev wdev; 414 415 /* keys */ 416 struct list_head key_list; 417 418 struct net_device *dev; 419 struct ieee80211_local *local; 420 421 unsigned int flags; 422 423 int drop_unencrypted; 424 425 /* 426 * keep track of whether the HT opmode (stored in 427 * vif.bss_info.ht_operation_mode) is valid. 428 */ 429 bool ht_opmode_valid; 430 431 /* Fragment table for host-based reassembly */ 432 struct ieee80211_fragment_entry fragments[IEEE80211_FRAGMENT_MAX]; 433 unsigned int fragment_next; 434 435 #define NUM_DEFAULT_KEYS 4 436 #define NUM_DEFAULT_MGMT_KEYS 2 437 struct ieee80211_key *keys[NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS]; 438 struct ieee80211_key *default_key; 439 struct ieee80211_key *default_mgmt_key; 440 441 u16 sequence_number; 442 443 /* 444 * AP this belongs to: self in AP mode and 445 * corresponding AP in VLAN mode, NULL for 446 * all others (might be needed later in IBSS) 447 */ 448 struct ieee80211_if_ap *bss; 449 450 int force_unicast_rateidx; /* forced TX rateidx for unicast frames */ 451 int max_ratectrl_rateidx; /* max TX rateidx for rate control */ 452 453 union { 454 struct ieee80211_if_ap ap; 455 struct ieee80211_if_wds wds; 456 struct ieee80211_if_vlan vlan; 457 struct ieee80211_if_managed mgd; 458 struct ieee80211_if_ibss ibss; 459 #ifdef CONFIG_MAC80211_MESH 460 struct ieee80211_if_mesh mesh; 461 #endif 462 u32 mntr_flags; 463 } u; 464 465 #ifdef CONFIG_MAC80211_DEBUGFS 466 struct dentry *debugfsdir; 467 union { 468 struct { 469 struct dentry *drop_unencrypted; 470 struct dentry *bssid; 471 struct dentry *aid; 472 struct dentry *capab; 473 struct dentry *force_unicast_rateidx; 474 struct dentry *max_ratectrl_rateidx; 475 } sta; 476 struct { 477 struct dentry *drop_unencrypted; 478 struct dentry *num_sta_ps; 479 struct dentry *dtim_count; 480 struct dentry *force_unicast_rateidx; 481 struct dentry *max_ratectrl_rateidx; 482 struct dentry *num_buffered_multicast; 483 } ap; 484 struct { 485 struct dentry *drop_unencrypted; 486 struct dentry *peer; 487 struct dentry *force_unicast_rateidx; 488 struct dentry *max_ratectrl_rateidx; 489 } wds; 490 struct { 491 struct dentry *drop_unencrypted; 492 struct dentry *force_unicast_rateidx; 493 struct dentry *max_ratectrl_rateidx; 494 } vlan; 495 struct { 496 struct dentry *mode; 497 } monitor; 498 } debugfs; 499 struct { 500 struct dentry *default_key; 501 struct dentry *default_mgmt_key; 502 } common_debugfs; 503 504 #ifdef CONFIG_MAC80211_MESH 505 struct dentry *mesh_stats_dir; 506 struct { 507 struct dentry *fwded_frames; 508 struct dentry *dropped_frames_ttl; 509 struct dentry *dropped_frames_no_route; 510 struct dentry *estab_plinks; 511 struct timer_list mesh_path_timer; 512 } mesh_stats; 513 514 struct dentry *mesh_config_dir; 515 struct { 516 struct dentry *dot11MeshRetryTimeout; 517 struct dentry *dot11MeshConfirmTimeout; 518 struct dentry *dot11MeshHoldingTimeout; 519 struct dentry *dot11MeshMaxRetries; 520 struct dentry *dot11MeshTTL; 521 struct dentry *auto_open_plinks; 522 struct dentry *dot11MeshMaxPeerLinks; 523 struct dentry *dot11MeshHWMPactivePathTimeout; 524 struct dentry *dot11MeshHWMPpreqMinInterval; 525 struct dentry *dot11MeshHWMPnetDiameterTraversalTime; 526 struct dentry *dot11MeshHWMPmaxPREQretries; 527 struct dentry *path_refresh_time; 528 struct dentry *min_discovery_timeout; 529 } mesh_config; 530 #endif 531 532 #endif 533 /* must be last, dynamically sized area in this! */ 534 struct ieee80211_vif vif; 535 }; 536 537 static inline 538 struct ieee80211_sub_if_data *vif_to_sdata(struct ieee80211_vif *p) 539 { 540 return container_of(p, struct ieee80211_sub_if_data, vif); 541 } 542 543 static inline void 544 ieee80211_sdata_set_mesh_id(struct ieee80211_sub_if_data *sdata, 545 u8 mesh_id_len, u8 *mesh_id) 546 { 547 #ifdef CONFIG_MAC80211_MESH 548 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 549 ifmsh->mesh_id_len = mesh_id_len; 550 memcpy(ifmsh->mesh_id, mesh_id, mesh_id_len); 551 #else 552 WARN_ON(1); 553 #endif 554 } 555 556 enum { 557 IEEE80211_RX_MSG = 1, 558 IEEE80211_TX_STATUS_MSG = 2, 559 IEEE80211_DELBA_MSG = 3, 560 IEEE80211_ADDBA_MSG = 4, 561 }; 562 563 enum queue_stop_reason { 564 IEEE80211_QUEUE_STOP_REASON_DRIVER, 565 IEEE80211_QUEUE_STOP_REASON_PS, 566 IEEE80211_QUEUE_STOP_REASON_CSA, 567 IEEE80211_QUEUE_STOP_REASON_AGGREGATION, 568 IEEE80211_QUEUE_STOP_REASON_SUSPEND, 569 IEEE80211_QUEUE_STOP_REASON_SKB_ADD, 570 }; 571 572 /** 573 * mac80211 scan flags - currently active scan mode 574 * 575 * @SCAN_SW_SCANNING: We're currently in the process of scanning but may as 576 * well be on the operating channel 577 * @SCAN_HW_SCANNING: The hardware is scanning for us, we have no way to 578 * determine if we are on the operating channel or not 579 * @SCAN_OFF_CHANNEL: We're off our operating channel for scanning, 580 * gets only set in conjunction with SCAN_SW_SCANNING 581 */ 582 enum { 583 SCAN_SW_SCANNING, 584 SCAN_HW_SCANNING, 585 SCAN_OFF_CHANNEL, 586 }; 587 588 /** 589 * enum mac80211_scan_state - scan state machine states 590 * 591 * @SCAN_DECISION: Main entry point to the scan state machine, this state 592 * determines if we should keep on scanning or switch back to the 593 * operating channel 594 * @SCAN_SET_CHANNEL: Set the next channel to be scanned 595 * @SCAN_SEND_PROBE: Send probe requests and wait for probe responses 596 * @SCAN_LEAVE_OPER_CHANNEL: Leave the operating channel, notify the AP 597 * about us leaving the channel and stop all associated STA interfaces 598 * @SCAN_ENTER_OPER_CHANNEL: Enter the operating channel again, notify the 599 * AP about us being back and restart all associated STA interfaces 600 */ 601 enum mac80211_scan_state { 602 SCAN_DECISION, 603 SCAN_SET_CHANNEL, 604 SCAN_SEND_PROBE, 605 SCAN_LEAVE_OPER_CHANNEL, 606 SCAN_ENTER_OPER_CHANNEL, 607 }; 608 609 struct ieee80211_local { 610 /* embed the driver visible part. 611 * don't cast (use the static inlines below), but we keep 612 * it first anyway so they become a no-op */ 613 struct ieee80211_hw hw; 614 615 const struct ieee80211_ops *ops; 616 617 unsigned long queue_stop_reasons[IEEE80211_MAX_QUEUES]; 618 /* also used to protect ampdu_ac_queue and amdpu_ac_stop_refcnt */ 619 spinlock_t queue_stop_reason_lock; 620 621 int open_count; 622 int monitors, cooked_mntrs; 623 /* number of interfaces with corresponding FIF_ flags */ 624 int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss; 625 unsigned int filter_flags; /* FIF_* */ 626 struct iw_statistics wstats; 627 628 /* protects the aggregated multicast list and filter calls */ 629 spinlock_t filter_lock; 630 631 /* aggregated multicast list */ 632 struct dev_addr_list *mc_list; 633 int mc_count; 634 635 bool tim_in_locked_section; /* see ieee80211_beacon_get() */ 636 637 /* 638 * suspended is true if we finished all the suspend _and_ we have 639 * not yet come up from resume. This is to be used by mac80211 640 * to ensure driver sanity during suspend and mac80211's own 641 * sanity. It can eventually be used for WoW as well. 642 */ 643 bool suspended; 644 645 /* 646 * quiescing is true during the suspend process _only_ to 647 * ease timer cancelling etc. 648 */ 649 bool quiescing; 650 651 int tx_headroom; /* required headroom for hardware/radiotap */ 652 653 /* Tasklet and skb queue to process calls from IRQ mode. All frames 654 * added to skb_queue will be processed, but frames in 655 * skb_queue_unreliable may be dropped if the total length of these 656 * queues increases over the limit. */ 657 #define IEEE80211_IRQSAFE_QUEUE_LIMIT 128 658 struct tasklet_struct tasklet; 659 struct sk_buff_head skb_queue; 660 struct sk_buff_head skb_queue_unreliable; 661 662 /* Station data */ 663 /* 664 * The lock only protects the list, hash, timer and counter 665 * against manipulation, reads are done in RCU. Additionally, 666 * the lock protects each BSS's TIM bitmap. 667 */ 668 spinlock_t sta_lock; 669 unsigned long num_sta; 670 struct list_head sta_list; 671 struct sta_info *sta_hash[STA_HASH_SIZE]; 672 struct timer_list sta_cleanup; 673 674 struct sk_buff_head pending[IEEE80211_MAX_QUEUES]; 675 struct tasklet_struct tx_pending_tasklet; 676 677 /* 678 * This lock is used to prevent concurrent A-MPDU 679 * session start/stop processing, this thus also 680 * synchronises the ->ampdu_action() callback to 681 * drivers and limits it to one at a time. 682 */ 683 spinlock_t ampdu_lock; 684 685 /* number of interfaces with corresponding IFF_ flags */ 686 atomic_t iff_allmultis, iff_promiscs; 687 688 struct rate_control_ref *rate_ctrl; 689 690 struct crypto_blkcipher *wep_tx_tfm; 691 struct crypto_blkcipher *wep_rx_tfm; 692 u32 wep_iv; 693 694 /* see iface.c */ 695 struct list_head interfaces; 696 struct mutex iflist_mtx; 697 698 /* 699 * Key lock, protects sdata's key_list and sta_info's 700 * key pointers (write access, they're RCU.) 701 */ 702 spinlock_t key_lock; 703 704 705 /* Scanning and BSS list */ 706 struct mutex scan_mtx; 707 unsigned long scanning; 708 struct cfg80211_ssid scan_ssid; 709 struct cfg80211_scan_request int_scan_req; 710 struct cfg80211_scan_request *scan_req; 711 struct ieee80211_channel *scan_channel; 712 const u8 *orig_ies; 713 int orig_ies_len; 714 int scan_channel_idx; 715 int scan_ies_len; 716 717 enum mac80211_scan_state next_scan_state; 718 struct delayed_work scan_work; 719 struct ieee80211_sub_if_data *scan_sdata; 720 enum nl80211_channel_type oper_channel_type; 721 struct ieee80211_channel *oper_channel, *csa_channel; 722 723 /* SNMP counters */ 724 /* dot11CountersTable */ 725 u32 dot11TransmittedFragmentCount; 726 u32 dot11MulticastTransmittedFrameCount; 727 u32 dot11FailedCount; 728 u32 dot11RetryCount; 729 u32 dot11MultipleRetryCount; 730 u32 dot11FrameDuplicateCount; 731 u32 dot11ReceivedFragmentCount; 732 u32 dot11MulticastReceivedFrameCount; 733 u32 dot11TransmittedFrameCount; 734 735 #ifdef CONFIG_MAC80211_LEDS 736 int tx_led_counter, rx_led_counter; 737 struct led_trigger *tx_led, *rx_led, *assoc_led, *radio_led; 738 char tx_led_name[32], rx_led_name[32], 739 assoc_led_name[32], radio_led_name[32]; 740 #endif 741 742 #ifdef CONFIG_MAC80211_DEBUGFS 743 struct work_struct sta_debugfs_add; 744 #endif 745 746 #ifdef CONFIG_MAC80211_DEBUG_COUNTERS 747 /* TX/RX handler statistics */ 748 unsigned int tx_handlers_drop; 749 unsigned int tx_handlers_queued; 750 unsigned int tx_handlers_drop_unencrypted; 751 unsigned int tx_handlers_drop_fragment; 752 unsigned int tx_handlers_drop_wep; 753 unsigned int tx_handlers_drop_not_assoc; 754 unsigned int tx_handlers_drop_unauth_port; 755 unsigned int rx_handlers_drop; 756 unsigned int rx_handlers_queued; 757 unsigned int rx_handlers_drop_nullfunc; 758 unsigned int rx_handlers_drop_defrag; 759 unsigned int rx_handlers_drop_short; 760 unsigned int rx_handlers_drop_passive_scan; 761 unsigned int tx_expand_skb_head; 762 unsigned int tx_expand_skb_head_cloned; 763 unsigned int rx_expand_skb_head; 764 unsigned int rx_expand_skb_head2; 765 unsigned int rx_handlers_fragments; 766 unsigned int tx_status_drop; 767 #define I802_DEBUG_INC(c) (c)++ 768 #else /* CONFIG_MAC80211_DEBUG_COUNTERS */ 769 #define I802_DEBUG_INC(c) do { } while (0) 770 #endif /* CONFIG_MAC80211_DEBUG_COUNTERS */ 771 772 773 int total_ps_buffered; /* total number of all buffered unicast and 774 * multicast packets for power saving stations 775 */ 776 int wifi_wme_noack_test; 777 unsigned int wmm_acm; /* bit field of ACM bits (BIT(802.1D tag)) */ 778 779 bool pspolling; 780 /* 781 * PS can only be enabled when we have exactly one managed 782 * interface (and monitors) in PS, this then points there. 783 */ 784 struct ieee80211_sub_if_data *ps_sdata; 785 struct work_struct dynamic_ps_enable_work; 786 struct work_struct dynamic_ps_disable_work; 787 struct timer_list dynamic_ps_timer; 788 struct notifier_block network_latency_notifier; 789 790 int user_power_level; /* in dBm */ 791 int power_constr_level; /* in dBm */ 792 793 struct work_struct restart_work; 794 795 #ifdef CONFIG_MAC80211_DEBUGFS 796 struct local_debugfsdentries { 797 struct dentry *rcdir; 798 struct dentry *rcname; 799 struct dentry *frequency; 800 struct dentry *total_ps_buffered; 801 struct dentry *wep_iv; 802 struct dentry *tsf; 803 struct dentry *queues; 804 struct dentry *reset; 805 struct dentry *noack; 806 struct dentry *statistics; 807 struct local_debugfsdentries_statsdentries { 808 struct dentry *transmitted_fragment_count; 809 struct dentry *multicast_transmitted_frame_count; 810 struct dentry *failed_count; 811 struct dentry *retry_count; 812 struct dentry *multiple_retry_count; 813 struct dentry *frame_duplicate_count; 814 struct dentry *received_fragment_count; 815 struct dentry *multicast_received_frame_count; 816 struct dentry *transmitted_frame_count; 817 struct dentry *wep_undecryptable_count; 818 struct dentry *num_scans; 819 #ifdef CONFIG_MAC80211_DEBUG_COUNTERS 820 struct dentry *tx_handlers_drop; 821 struct dentry *tx_handlers_queued; 822 struct dentry *tx_handlers_drop_unencrypted; 823 struct dentry *tx_handlers_drop_fragment; 824 struct dentry *tx_handlers_drop_wep; 825 struct dentry *tx_handlers_drop_not_assoc; 826 struct dentry *tx_handlers_drop_unauth_port; 827 struct dentry *rx_handlers_drop; 828 struct dentry *rx_handlers_queued; 829 struct dentry *rx_handlers_drop_nullfunc; 830 struct dentry *rx_handlers_drop_defrag; 831 struct dentry *rx_handlers_drop_short; 832 struct dentry *rx_handlers_drop_passive_scan; 833 struct dentry *tx_expand_skb_head; 834 struct dentry *tx_expand_skb_head_cloned; 835 struct dentry *rx_expand_skb_head; 836 struct dentry *rx_expand_skb_head2; 837 struct dentry *rx_handlers_fragments; 838 struct dentry *tx_status_drop; 839 #endif 840 struct dentry *dot11ACKFailureCount; 841 struct dentry *dot11RTSFailureCount; 842 struct dentry *dot11FCSErrorCount; 843 struct dentry *dot11RTSSuccessCount; 844 } stats; 845 struct dentry *stations; 846 struct dentry *keys; 847 } debugfs; 848 #endif 849 }; 850 851 static inline struct ieee80211_sub_if_data * 852 IEEE80211_DEV_TO_SUB_IF(struct net_device *dev) 853 { 854 return netdev_priv(dev); 855 } 856 857 /* this struct represents 802.11n's RA/TID combination */ 858 struct ieee80211_ra_tid { 859 u8 ra[ETH_ALEN]; 860 u16 tid; 861 }; 862 863 /* Parsed Information Elements */ 864 struct ieee802_11_elems { 865 u8 *ie_start; 866 size_t total_len; 867 868 /* pointers to IEs */ 869 u8 *ssid; 870 u8 *supp_rates; 871 u8 *fh_params; 872 u8 *ds_params; 873 u8 *cf_params; 874 struct ieee80211_tim_ie *tim; 875 u8 *ibss_params; 876 u8 *challenge; 877 u8 *wpa; 878 u8 *rsn; 879 u8 *erp_info; 880 u8 *ext_supp_rates; 881 u8 *wmm_info; 882 u8 *wmm_param; 883 struct ieee80211_ht_cap *ht_cap_elem; 884 struct ieee80211_ht_info *ht_info_elem; 885 u8 *mesh_config; 886 u8 *mesh_id; 887 u8 *peer_link; 888 u8 *preq; 889 u8 *prep; 890 u8 *perr; 891 u8 *ch_switch_elem; 892 u8 *country_elem; 893 u8 *pwr_constr_elem; 894 u8 *quiet_elem; /* first quite element */ 895 u8 *timeout_int; 896 897 /* length of them, respectively */ 898 u8 ssid_len; 899 u8 supp_rates_len; 900 u8 fh_params_len; 901 u8 ds_params_len; 902 u8 cf_params_len; 903 u8 tim_len; 904 u8 ibss_params_len; 905 u8 challenge_len; 906 u8 wpa_len; 907 u8 rsn_len; 908 u8 erp_info_len; 909 u8 ext_supp_rates_len; 910 u8 wmm_info_len; 911 u8 wmm_param_len; 912 u8 mesh_config_len; 913 u8 mesh_id_len; 914 u8 peer_link_len; 915 u8 preq_len; 916 u8 prep_len; 917 u8 perr_len; 918 u8 ch_switch_elem_len; 919 u8 country_elem_len; 920 u8 pwr_constr_elem_len; 921 u8 quiet_elem_len; 922 u8 num_of_quiet_elem; /* can be more the one */ 923 u8 timeout_int_len; 924 }; 925 926 static inline struct ieee80211_local *hw_to_local( 927 struct ieee80211_hw *hw) 928 { 929 return container_of(hw, struct ieee80211_local, hw); 930 } 931 932 static inline struct ieee80211_hw *local_to_hw( 933 struct ieee80211_local *local) 934 { 935 return &local->hw; 936 } 937 938 939 static inline int ieee80211_bssid_match(const u8 *raddr, const u8 *addr) 940 { 941 return compare_ether_addr(raddr, addr) == 0 || 942 is_broadcast_ether_addr(raddr); 943 } 944 945 946 int ieee80211_hw_config(struct ieee80211_local *local, u32 changed); 947 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx); 948 void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata, 949 u32 changed); 950 void ieee80211_configure_filter(struct ieee80211_local *local); 951 u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata); 952 953 /* STA code */ 954 void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata); 955 int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata, 956 struct cfg80211_auth_request *req); 957 int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata, 958 struct cfg80211_assoc_request *req); 959 int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata, 960 struct cfg80211_deauth_request *req, 961 void *cookie); 962 int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata, 963 struct cfg80211_disassoc_request *req, 964 void *cookie); 965 ieee80211_rx_result ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata, 966 struct sk_buff *skb); 967 void ieee80211_send_pspoll(struct ieee80211_local *local, 968 struct ieee80211_sub_if_data *sdata); 969 void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency); 970 int ieee80211_max_network_latency(struct notifier_block *nb, 971 unsigned long data, void *dummy); 972 void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata, 973 struct ieee80211_channel_sw_ie *sw_elem, 974 struct ieee80211_bss *bss); 975 void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata); 976 void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata); 977 978 /* IBSS code */ 979 void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local); 980 void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata); 981 ieee80211_rx_result 982 ieee80211_ibss_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb); 983 struct sta_info *ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata, 984 u8 *bssid, u8 *addr, u32 supp_rates); 985 int ieee80211_ibss_join(struct ieee80211_sub_if_data *sdata, 986 struct cfg80211_ibss_params *params); 987 int ieee80211_ibss_leave(struct ieee80211_sub_if_data *sdata); 988 void ieee80211_ibss_quiesce(struct ieee80211_sub_if_data *sdata); 989 void ieee80211_ibss_restart(struct ieee80211_sub_if_data *sdata); 990 991 /* scan/BSS handling */ 992 void ieee80211_scan_work(struct work_struct *work); 993 int ieee80211_request_internal_scan(struct ieee80211_sub_if_data *sdata, 994 const u8 *ssid, u8 ssid_len); 995 int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata, 996 struct cfg80211_scan_request *req); 997 void ieee80211_scan_cancel(struct ieee80211_local *local); 998 ieee80211_rx_result 999 ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb); 1000 1001 void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local); 1002 struct ieee80211_bss * 1003 ieee80211_bss_info_update(struct ieee80211_local *local, 1004 struct ieee80211_rx_status *rx_status, 1005 struct ieee80211_mgmt *mgmt, 1006 size_t len, 1007 struct ieee802_11_elems *elems, 1008 struct ieee80211_channel *channel, 1009 bool beacon); 1010 struct ieee80211_bss * 1011 ieee80211_rx_bss_get(struct ieee80211_local *local, u8 *bssid, int freq, 1012 u8 *ssid, u8 ssid_len); 1013 void ieee80211_rx_bss_put(struct ieee80211_local *local, 1014 struct ieee80211_bss *bss); 1015 1016 /* interface handling */ 1017 int ieee80211_if_add(struct ieee80211_local *local, const char *name, 1018 struct net_device **new_dev, enum nl80211_iftype type, 1019 struct vif_params *params); 1020 int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata, 1021 enum nl80211_iftype type); 1022 void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata); 1023 void ieee80211_remove_interfaces(struct ieee80211_local *local); 1024 u32 __ieee80211_recalc_idle(struct ieee80211_local *local); 1025 void ieee80211_recalc_idle(struct ieee80211_local *local); 1026 1027 /* tx handling */ 1028 void ieee80211_clear_tx_pending(struct ieee80211_local *local); 1029 void ieee80211_tx_pending(unsigned long data); 1030 int ieee80211_monitor_start_xmit(struct sk_buff *skb, struct net_device *dev); 1031 int ieee80211_subif_start_xmit(struct sk_buff *skb, struct net_device *dev); 1032 1033 /* HT */ 1034 void ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_supported_band *sband, 1035 struct ieee80211_ht_cap *ht_cap_ie, 1036 struct ieee80211_sta_ht_cap *ht_cap); 1037 void ieee80211_send_bar(struct ieee80211_sub_if_data *sdata, u8 *ra, u16 tid, u16 ssn); 1038 void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata, 1039 const u8 *da, u16 tid, 1040 u16 initiator, u16 reason_code); 1041 1042 void ieee80211_sta_stop_rx_ba_session(struct ieee80211_sub_if_data *sdata, u8 *da, 1043 u16 tid, u16 initiator, u16 reason); 1044 void __ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid, 1045 u16 initiator, u16 reason); 1046 void ieee80211_sta_tear_down_BA_sessions(struct sta_info *sta); 1047 void ieee80211_process_delba(struct ieee80211_sub_if_data *sdata, 1048 struct sta_info *sta, 1049 struct ieee80211_mgmt *mgmt, size_t len); 1050 void ieee80211_process_addba_resp(struct ieee80211_local *local, 1051 struct sta_info *sta, 1052 struct ieee80211_mgmt *mgmt, 1053 size_t len); 1054 void ieee80211_process_addba_request(struct ieee80211_local *local, 1055 struct sta_info *sta, 1056 struct ieee80211_mgmt *mgmt, 1057 size_t len); 1058 1059 int __ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid, 1060 enum ieee80211_back_parties initiator); 1061 1062 /* Spectrum management */ 1063 void ieee80211_process_measurement_req(struct ieee80211_sub_if_data *sdata, 1064 struct ieee80211_mgmt *mgmt, 1065 size_t len); 1066 1067 /* Suspend/resume and hw reconfiguration */ 1068 int ieee80211_reconfig(struct ieee80211_local *local); 1069 1070 #ifdef CONFIG_PM 1071 int __ieee80211_suspend(struct ieee80211_hw *hw); 1072 1073 static inline int __ieee80211_resume(struct ieee80211_hw *hw) 1074 { 1075 return ieee80211_reconfig(hw_to_local(hw)); 1076 } 1077 #else 1078 static inline int __ieee80211_suspend(struct ieee80211_hw *hw) 1079 { 1080 return 0; 1081 } 1082 1083 static inline int __ieee80211_resume(struct ieee80211_hw *hw) 1084 { 1085 return 0; 1086 } 1087 #endif 1088 1089 /* utility functions/constants */ 1090 extern void *mac80211_wiphy_privid; /* for wiphy privid */ 1091 u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len, 1092 enum nl80211_iftype type); 1093 int ieee80211_frame_duration(struct ieee80211_local *local, size_t len, 1094 int rate, int erp, int short_preamble); 1095 void mac80211_ev_michael_mic_failure(struct ieee80211_sub_if_data *sdata, int keyidx, 1096 struct ieee80211_hdr *hdr, const u8 *tsc, 1097 gfp_t gfp); 1098 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata); 1099 void ieee80211_tx_skb(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb, 1100 int encrypt); 1101 void ieee802_11_parse_elems(u8 *start, size_t len, 1102 struct ieee802_11_elems *elems); 1103 u32 ieee802_11_parse_elems_crc(u8 *start, size_t len, 1104 struct ieee802_11_elems *elems, 1105 u64 filter, u32 crc); 1106 u32 ieee80211_mandatory_rates(struct ieee80211_local *local, 1107 enum ieee80211_band band); 1108 1109 void ieee80211_dynamic_ps_enable_work(struct work_struct *work); 1110 void ieee80211_dynamic_ps_disable_work(struct work_struct *work); 1111 void ieee80211_dynamic_ps_timer(unsigned long data); 1112 void ieee80211_send_nullfunc(struct ieee80211_local *local, 1113 struct ieee80211_sub_if_data *sdata, 1114 int powersave); 1115 void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata, 1116 struct ieee80211_hdr *hdr); 1117 void ieee80211_beacon_loss_work(struct work_struct *work); 1118 1119 void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw, 1120 enum queue_stop_reason reason); 1121 void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw, 1122 enum queue_stop_reason reason); 1123 void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue, 1124 enum queue_stop_reason reason); 1125 void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue, 1126 enum queue_stop_reason reason); 1127 void ieee80211_add_pending_skb(struct ieee80211_local *local, 1128 struct sk_buff *skb); 1129 int ieee80211_add_pending_skbs(struct ieee80211_local *local, 1130 struct sk_buff_head *skbs); 1131 1132 void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata, 1133 u16 transaction, u16 auth_alg, 1134 u8 *extra, size_t extra_len, const u8 *bssid, 1135 const u8 *key, u8 key_len, u8 key_idx); 1136 int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer, 1137 const u8 *ie, size_t ie_len); 1138 void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst, 1139 const u8 *ssid, size_t ssid_len, 1140 const u8 *ie, size_t ie_len); 1141 1142 void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata, 1143 const size_t supp_rates_len, 1144 const u8 *supp_rates); 1145 u32 ieee80211_sta_get_rates(struct ieee80211_local *local, 1146 struct ieee802_11_elems *elems, 1147 enum ieee80211_band band); 1148 1149 #ifdef CONFIG_MAC80211_NOINLINE 1150 #define debug_noinline noinline 1151 #else 1152 #define debug_noinline 1153 #endif 1154 1155 #endif /* IEEE80211_I_H */ 1156