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