1/****************************************************************************** 2 * 3 * This file is provided under a dual BSD/GPLv2 license. When using or 4 * redistributing this file, you may do so under either license. 5 * 6 * GPL LICENSE SUMMARY 7 * 8 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved. 9 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of version 2 of the GNU General Public License as 13 * published by the Free Software Foundation. 14 * 15 * This program is distributed in the hope that it will be useful, but 16 * WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, 23 * USA 24 * 25 * The full GNU General Public License is included in this distribution 26 * in the file called COPYING. 27 * 28 * Contact Information: 29 * Intel Linux Wireless <ilw@linux.intel.com> 30 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 31 * 32 * BSD LICENSE 33 * 34 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved. 35 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH 36 * All rights reserved. 37 * 38 * Redistribution and use in source and binary forms, with or without 39 * modification, are permitted provided that the following conditions 40 * are met: 41 * 42 * * Redistributions of source code must retain the above copyright 43 * notice, this list of conditions and the following disclaimer. 44 * * Redistributions in binary form must reproduce the above copyright 45 * notice, this list of conditions and the following disclaimer in 46 * the documentation and/or other materials provided with the 47 * distribution. 48 * * Neither the name Intel Corporation nor the names of its 49 * contributors may be used to endorse or promote products derived 50 * from this software without specific prior written permission. 51 * 52 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 53 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 54 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 55 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 56 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 57 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 58 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 59 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 60 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 61 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 62 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 63 * 64 *****************************************************************************/ 65 66#ifndef __IWL_MVM_H__ 67#define __IWL_MVM_H__ 68 69#include <linux/list.h> 70#include <linux/spinlock.h> 71#include <linux/leds.h> 72#include <linux/in6.h> 73 74#include "iwl-op-mode.h" 75#include "iwl-trans.h" 76#include "iwl-notif-wait.h" 77#include "iwl-eeprom-parse.h" 78#include "sta.h" 79#include "fw-api.h" 80#include "constants.h" 81 82#define IWL_INVALID_MAC80211_QUEUE 0xff 83#define IWL_MVM_MAX_ADDRESSES 5 84/* RSSI offset for WkP */ 85#define IWL_RSSI_OFFSET 50 86#define IWL_MVM_MISSED_BEACONS_THRESHOLD 8 87/* A TimeUnit is 1024 microsecond */ 88#define MSEC_TO_TU(_msec) (_msec*1000/1024) 89 90/* This value represents the number of TUs before CSA "beacon 0" TBTT 91 * when the CSA time-event needs to be scheduled to start. It must be 92 * big enough to ensure that we switch in time. 93 */ 94#define IWL_MVM_CHANNEL_SWITCH_TIME_GO 40 95 96/* 97 * This value (in TUs) is used to fine tune the CSA NoA end time which should 98 * be just before "beacon 0" TBTT. 99 */ 100#define IWL_MVM_CHANNEL_SWITCH_MARGIN 4 101 102/* 103 * Number of beacons to transmit on a new channel until we unblock tx to 104 * the stations, even if we didn't identify them on a new channel 105 */ 106#define IWL_MVM_CS_UNBLOCK_TX_TIMEOUT 3 107 108extern const struct ieee80211_ops iwl_mvm_hw_ops; 109 110/** 111 * struct iwl_mvm_mod_params - module parameters for iwlmvm 112 * @init_dbg: if true, then the NIC won't be stopped if the INIT fw asserted. 113 * We will register to mac80211 to have testmode working. The NIC must not 114 * be up'ed after the INIT fw asserted. This is useful to be able to use 115 * proprietary tools over testmode to debug the INIT fw. 116 * @power_scheme: CAM(Continuous Active Mode)-1, BPS(Balanced Power 117 * Save)-2(default), LP(Low Power)-3 118 */ 119struct iwl_mvm_mod_params { 120 bool init_dbg; 121 int power_scheme; 122}; 123extern struct iwl_mvm_mod_params iwlmvm_mod_params; 124 125/** 126 * struct iwl_mvm_dump_ptrs - set of pointers needed for the fw-error-dump 127 * 128 * @op_mode_ptr: pointer to the buffer coming from the mvm op_mode 129 * @trans_ptr: pointer to struct %iwl_trans_dump_data which contains the 130 * transport's data. 131 * @trans_len: length of the valid data in trans_ptr 132 * @op_mode_len: length of the valid data in op_mode_ptr 133 */ 134struct iwl_mvm_dump_ptrs { 135 struct iwl_trans_dump_data *trans_ptr; 136 void *op_mode_ptr; 137 u32 op_mode_len; 138}; 139 140struct iwl_mvm_phy_ctxt { 141 u16 id; 142 u16 color; 143 u32 ref; 144 145 /* 146 * TODO: This should probably be removed. Currently here only for rate 147 * scaling algorithm 148 */ 149 struct ieee80211_channel *channel; 150}; 151 152struct iwl_mvm_time_event_data { 153 struct ieee80211_vif *vif; 154 struct list_head list; 155 unsigned long end_jiffies; 156 u32 duration; 157 bool running; 158 u32 uid; 159 160 /* 161 * The access to the 'id' field must be done when the 162 * mvm->time_event_lock is held, as it value is used to indicate 163 * if the te is in the time event list or not (when id == TE_MAX) 164 */ 165 u32 id; 166}; 167 168 /* Power management */ 169 170/** 171 * enum iwl_power_scheme 172 * @IWL_POWER_LEVEL_CAM - Continuously Active Mode 173 * @IWL_POWER_LEVEL_BPS - Balanced Power Save (default) 174 * @IWL_POWER_LEVEL_LP - Low Power 175 */ 176enum iwl_power_scheme { 177 IWL_POWER_SCHEME_CAM = 1, 178 IWL_POWER_SCHEME_BPS, 179 IWL_POWER_SCHEME_LP 180}; 181 182#define IWL_CONN_MAX_LISTEN_INTERVAL 10 183#define IWL_UAPSD_MAX_SP IEEE80211_WMM_IE_STA_QOSINFO_SP_2 184 185#ifdef CONFIG_IWLWIFI_DEBUGFS 186enum iwl_dbgfs_pm_mask { 187 MVM_DEBUGFS_PM_KEEP_ALIVE = BIT(0), 188 MVM_DEBUGFS_PM_SKIP_OVER_DTIM = BIT(1), 189 MVM_DEBUGFS_PM_SKIP_DTIM_PERIODS = BIT(2), 190 MVM_DEBUGFS_PM_RX_DATA_TIMEOUT = BIT(3), 191 MVM_DEBUGFS_PM_TX_DATA_TIMEOUT = BIT(4), 192 MVM_DEBUGFS_PM_LPRX_ENA = BIT(6), 193 MVM_DEBUGFS_PM_LPRX_RSSI_THRESHOLD = BIT(7), 194 MVM_DEBUGFS_PM_SNOOZE_ENABLE = BIT(8), 195 MVM_DEBUGFS_PM_UAPSD_MISBEHAVING = BIT(9), 196 MVM_DEBUGFS_PM_USE_PS_POLL = BIT(10), 197}; 198 199struct iwl_dbgfs_pm { 200 u16 keep_alive_seconds; 201 u32 rx_data_timeout; 202 u32 tx_data_timeout; 203 bool skip_over_dtim; 204 u8 skip_dtim_periods; 205 bool lprx_ena; 206 u32 lprx_rssi_threshold; 207 bool snooze_ena; 208 bool uapsd_misbehaving; 209 bool use_ps_poll; 210 int mask; 211}; 212 213/* beacon filtering */ 214 215enum iwl_dbgfs_bf_mask { 216 MVM_DEBUGFS_BF_ENERGY_DELTA = BIT(0), 217 MVM_DEBUGFS_BF_ROAMING_ENERGY_DELTA = BIT(1), 218 MVM_DEBUGFS_BF_ROAMING_STATE = BIT(2), 219 MVM_DEBUGFS_BF_TEMP_THRESHOLD = BIT(3), 220 MVM_DEBUGFS_BF_TEMP_FAST_FILTER = BIT(4), 221 MVM_DEBUGFS_BF_TEMP_SLOW_FILTER = BIT(5), 222 MVM_DEBUGFS_BF_ENABLE_BEACON_FILTER = BIT(6), 223 MVM_DEBUGFS_BF_DEBUG_FLAG = BIT(7), 224 MVM_DEBUGFS_BF_ESCAPE_TIMER = BIT(8), 225 MVM_DEBUGFS_BA_ESCAPE_TIMER = BIT(9), 226 MVM_DEBUGFS_BA_ENABLE_BEACON_ABORT = BIT(10), 227}; 228 229struct iwl_dbgfs_bf { 230 u32 bf_energy_delta; 231 u32 bf_roaming_energy_delta; 232 u32 bf_roaming_state; 233 u32 bf_temp_threshold; 234 u32 bf_temp_fast_filter; 235 u32 bf_temp_slow_filter; 236 u32 bf_enable_beacon_filter; 237 u32 bf_debug_flag; 238 u32 bf_escape_timer; 239 u32 ba_escape_timer; 240 u32 ba_enable_beacon_abort; 241 int mask; 242}; 243#endif 244 245enum iwl_mvm_smps_type_request { 246 IWL_MVM_SMPS_REQ_BT_COEX, 247 IWL_MVM_SMPS_REQ_TT, 248 IWL_MVM_SMPS_REQ_PROT, 249 NUM_IWL_MVM_SMPS_REQ, 250}; 251 252enum iwl_mvm_ref_type { 253 IWL_MVM_REF_UCODE_DOWN, 254 IWL_MVM_REF_SCAN, 255 IWL_MVM_REF_ROC, 256 IWL_MVM_REF_P2P_CLIENT, 257 IWL_MVM_REF_AP_IBSS, 258 IWL_MVM_REF_USER, 259 IWL_MVM_REF_TX, 260 IWL_MVM_REF_TX_AGG, 261 IWL_MVM_REF_ADD_IF, 262 IWL_MVM_REF_START_AP, 263 IWL_MVM_REF_BSS_CHANGED, 264 IWL_MVM_REF_PREPARE_TX, 265 IWL_MVM_REF_PROTECT_TDLS, 266 IWL_MVM_REF_CHECK_CTKILL, 267 IWL_MVM_REF_PRPH_READ, 268 IWL_MVM_REF_PRPH_WRITE, 269 IWL_MVM_REF_NMI, 270 IWL_MVM_REF_TM_CMD, 271 IWL_MVM_REF_EXIT_WORK, 272 273 /* update debugfs.c when changing this */ 274 275 IWL_MVM_REF_COUNT, 276}; 277 278enum iwl_bt_force_ant_mode { 279 BT_FORCE_ANT_DIS = 0, 280 BT_FORCE_ANT_AUTO, 281 BT_FORCE_ANT_BT, 282 BT_FORCE_ANT_WIFI, 283 284 BT_FORCE_ANT_MAX, 285}; 286 287/** 288* struct iwl_mvm_vif_bf_data - beacon filtering related data 289* @bf_enabled: indicates if beacon filtering is enabled 290* @ba_enabled: indicated if beacon abort is enabled 291* @last_beacon_signal: last beacon rssi signal in dbm 292* @ave_beacon_signal: average beacon signal 293* @last_cqm_event: rssi of the last cqm event 294* @bt_coex_min_thold: minimum threshold for BT coex 295* @bt_coex_max_thold: maximum threshold for BT coex 296* @last_bt_coex_event: rssi of the last BT coex event 297*/ 298struct iwl_mvm_vif_bf_data { 299 bool bf_enabled; 300 bool ba_enabled; 301 s8 ave_beacon_signal; 302 s8 last_cqm_event; 303 s8 bt_coex_min_thold; 304 s8 bt_coex_max_thold; 305 s8 last_bt_coex_event; 306}; 307 308/** 309 * struct iwl_mvm_vif - data per Virtual Interface, it is a MAC context 310 * @id: between 0 and 3 311 * @color: to solve races upon MAC addition and removal 312 * @ap_sta_id: the sta_id of the AP - valid only if VIF type is STA 313 * @bssid: BSSID for this (client) interface 314 * @associated: indicates that we're currently associated, used only for 315 * managing the firmware state in iwl_mvm_bss_info_changed_station() 316 * @uploaded: indicates the MAC context has been added to the device 317 * @ap_ibss_active: indicates that AP/IBSS is configured and that the interface 318 * should get quota etc. 319 * @pm_enabled - Indicate if MAC power management is allowed 320 * @monitor_active: indicates that monitor context is configured, and that the 321 * interface should get quota etc. 322 * @low_latency: indicates that this interface is in low-latency mode 323 * (VMACLowLatencyMode) 324 * @ps_disabled: indicates that this interface requires PS to be disabled 325 * @queue_params: QoS params for this MAC 326 * @bcast_sta: station used for broadcast packets. Used by the following 327 * vifs: P2P_DEVICE, GO and AP. 328 * @beacon_skb: the skb used to hold the AP/GO beacon template 329 * @smps_requests: the SMPS requests of differents parts of the driver, 330 * combined on update to yield the overall request to mac80211. 331 */ 332struct iwl_mvm_vif { 333 u16 id; 334 u16 color; 335 u8 ap_sta_id; 336 337 u8 bssid[ETH_ALEN]; 338 bool associated; 339 340 bool uploaded; 341 bool ap_ibss_active; 342 bool pm_enabled; 343 bool monitor_active; 344 bool low_latency; 345 bool ps_disabled; 346 struct iwl_mvm_vif_bf_data bf_data; 347 348 u32 ap_beacon_time; 349 350 enum iwl_tsf_id tsf_id; 351 352 /* 353 * QoS data from mac80211, need to store this here 354 * as mac80211 has a separate callback but we need 355 * to have the data for the MAC context 356 */ 357 struct ieee80211_tx_queue_params queue_params[IEEE80211_NUM_ACS]; 358 struct iwl_mvm_time_event_data time_event_data; 359 struct iwl_mvm_time_event_data hs_time_event_data; 360 361 struct iwl_mvm_int_sta bcast_sta; 362 363 /* 364 * Assigned while mac80211 has the interface in a channel context, 365 * or, for P2P Device, while it exists. 366 */ 367 struct iwl_mvm_phy_ctxt *phy_ctxt; 368 369#ifdef CONFIG_PM_SLEEP 370 /* WoWLAN GTK rekey data */ 371 struct { 372 u8 kck[NL80211_KCK_LEN], kek[NL80211_KEK_LEN]; 373 __le64 replay_ctr; 374 bool valid; 375 } rekey_data; 376 377 int tx_key_idx; 378 379 bool seqno_valid; 380 u16 seqno; 381#endif 382 383#if IS_ENABLED(CONFIG_IPV6) 384 /* IPv6 addresses for WoWLAN */ 385 struct in6_addr target_ipv6_addrs[IWL_PROTO_OFFLOAD_NUM_IPV6_ADDRS_MAX]; 386 int num_target_ipv6_addrs; 387#endif 388 389#ifdef CONFIG_IWLWIFI_DEBUGFS 390 struct iwl_mvm *mvm; 391 struct dentry *dbgfs_dir; 392 struct dentry *dbgfs_slink; 393 struct iwl_dbgfs_pm dbgfs_pm; 394 struct iwl_dbgfs_bf dbgfs_bf; 395 struct iwl_mac_power_cmd mac_pwr_cmd; 396#endif 397 398 enum ieee80211_smps_mode smps_requests[NUM_IWL_MVM_SMPS_REQ]; 399 400 /* FW identified misbehaving AP */ 401 u8 uapsd_misbehaving_bssid[ETH_ALEN]; 402}; 403 404static inline struct iwl_mvm_vif * 405iwl_mvm_vif_from_mac80211(struct ieee80211_vif *vif) 406{ 407 return (void *)vif->drv_priv; 408} 409 410extern const u8 tid_to_mac80211_ac[]; 411 412enum iwl_scan_status { 413 IWL_MVM_SCAN_NONE, 414 IWL_MVM_SCAN_OS, 415 IWL_MVM_SCAN_SCHED, 416}; 417 418/** 419 * struct iwl_nvm_section - describes an NVM section in memory. 420 * 421 * This struct holds an NVM section read from the NIC using NVM_ACCESS_CMD, 422 * and saved for later use by the driver. Not all NVM sections are saved 423 * this way, only the needed ones. 424 */ 425struct iwl_nvm_section { 426 u16 length; 427 const u8 *data; 428}; 429 430/* 431 * Tx-backoff threshold 432 * @temperature: The threshold in Celsius 433 * @backoff: The tx-backoff in uSec 434 */ 435struct iwl_tt_tx_backoff { 436 s32 temperature; 437 u32 backoff; 438}; 439 440#define TT_TX_BACKOFF_SIZE 6 441 442/** 443 * struct iwl_tt_params - thermal throttling parameters 444 * @ct_kill_entry: CT Kill entry threshold 445 * @ct_kill_exit: CT Kill exit threshold 446 * @ct_kill_duration: The time intervals (in uSec) in which the driver needs 447 * to checks whether to exit CT Kill. 448 * @dynamic_smps_entry: Dynamic SMPS entry threshold 449 * @dynamic_smps_exit: Dynamic SMPS exit threshold 450 * @tx_protection_entry: TX protection entry threshold 451 * @tx_protection_exit: TX protection exit threshold 452 * @tx_backoff: Array of thresholds for tx-backoff , in ascending order. 453 * @support_ct_kill: Support CT Kill? 454 * @support_dynamic_smps: Support dynamic SMPS? 455 * @support_tx_protection: Support tx protection? 456 * @support_tx_backoff: Support tx-backoff? 457 */ 458struct iwl_tt_params { 459 s32 ct_kill_entry; 460 s32 ct_kill_exit; 461 u32 ct_kill_duration; 462 s32 dynamic_smps_entry; 463 s32 dynamic_smps_exit; 464 s32 tx_protection_entry; 465 s32 tx_protection_exit; 466 struct iwl_tt_tx_backoff tx_backoff[TT_TX_BACKOFF_SIZE]; 467 bool support_ct_kill; 468 bool support_dynamic_smps; 469 bool support_tx_protection; 470 bool support_tx_backoff; 471}; 472 473/** 474 * struct iwl_mvm_tt_mgnt - Thermal Throttling Management structure 475 * @ct_kill_exit: worker to exit thermal kill 476 * @dynamic_smps: Is thermal throttling enabled dynamic_smps? 477 * @tx_backoff: The current thremal throttling tx backoff in uSec. 478 * @min_backoff: The minimal tx backoff due to power restrictions 479 * @params: Parameters to configure the thermal throttling algorithm. 480 * @throttle: Is thermal throttling is active? 481 */ 482struct iwl_mvm_tt_mgmt { 483 struct delayed_work ct_kill_exit; 484 bool dynamic_smps; 485 u32 tx_backoff; 486 u32 min_backoff; 487 const struct iwl_tt_params *params; 488 bool throttle; 489}; 490 491#define IWL_MVM_NUM_LAST_FRAMES_UCODE_RATES 8 492 493struct iwl_mvm_frame_stats { 494 u32 legacy_frames; 495 u32 ht_frames; 496 u32 vht_frames; 497 u32 bw_20_frames; 498 u32 bw_40_frames; 499 u32 bw_80_frames; 500 u32 bw_160_frames; 501 u32 sgi_frames; 502 u32 ngi_frames; 503 u32 siso_frames; 504 u32 mimo2_frames; 505 u32 agg_frames; 506 u32 ampdu_count; 507 u32 success_frames; 508 u32 fail_frames; 509 u32 last_rates[IWL_MVM_NUM_LAST_FRAMES_UCODE_RATES]; 510 int last_frame_idx; 511}; 512 513enum { 514 D0I3_DEFER_WAKEUP, 515 D0I3_PENDING_WAKEUP, 516}; 517 518#define IWL_MVM_DEBUG_SET_TEMPERATURE_DISABLE 0xff 519#define IWL_MVM_DEBUG_SET_TEMPERATURE_MIN -100 520#define IWL_MVM_DEBUG_SET_TEMPERATURE_MAX 200 521 522struct iwl_mvm { 523 /* for logger access */ 524 struct device *dev; 525 526 struct iwl_trans *trans; 527 const struct iwl_fw *fw; 528 const struct iwl_cfg *cfg; 529 struct iwl_phy_db *phy_db; 530 struct ieee80211_hw *hw; 531 532 /* for protecting access to iwl_mvm */ 533 struct mutex mutex; 534 struct list_head async_handlers_list; 535 spinlock_t async_handlers_lock; 536 struct work_struct async_handlers_wk; 537 538 struct work_struct roc_done_wk; 539 540 unsigned long status; 541 542 /* 543 * for beacon filtering - 544 * currently only one interface can be supported 545 */ 546 struct iwl_mvm_vif *bf_allowed_vif; 547 548 enum iwl_ucode_type cur_ucode; 549 bool ucode_loaded; 550 bool init_ucode_complete; 551 bool calibrating; 552 u32 error_event_table; 553 u32 log_event_table; 554 u32 umac_error_event_table; 555 bool support_umac_log; 556 struct iwl_sf_region sf_space; 557 558 u32 ampdu_ref; 559 560 struct iwl_notif_wait_data notif_wait; 561 562 struct mvm_statistics_rx rx_stats; 563 564 u8 queue_to_mac80211[IWL_MAX_HW_QUEUES]; 565 atomic_t mac80211_queue_stop_count[IEEE80211_MAX_QUEUES]; 566 567 const char *nvm_file_name; 568 struct iwl_nvm_data *nvm_data; 569 /* NVM sections */ 570 struct iwl_nvm_section nvm_sections[NVM_MAX_NUM_SECTIONS]; 571 572 /* EEPROM MAC addresses */ 573 struct mac_address addresses[IWL_MVM_MAX_ADDRESSES]; 574 575 /* data related to data path */ 576 struct iwl_rx_phy_info last_phy_info; 577 struct ieee80211_sta __rcu *fw_id_to_mac_id[IWL_MVM_STATION_COUNT]; 578 struct work_struct sta_drained_wk; 579 unsigned long sta_drained[BITS_TO_LONGS(IWL_MVM_STATION_COUNT)]; 580 atomic_t pending_frames[IWL_MVM_STATION_COUNT]; 581 u8 rx_ba_sessions; 582 583 /* configured by mac80211 */ 584 u32 rts_threshold; 585 586 /* Scan status, cmd (pre-allocated) and auxiliary station */ 587 enum iwl_scan_status scan_status; 588 void *scan_cmd; 589 struct iwl_mcast_filter_cmd *mcast_filter_cmd; 590 591 /* rx chain antennas set through debugfs for the scan command */ 592 u8 scan_rx_ant; 593 594#ifdef CONFIG_IWLWIFI_BCAST_FILTERING 595 /* broadcast filters to configure for each associated station */ 596 const struct iwl_fw_bcast_filter *bcast_filters; 597#ifdef CONFIG_IWLWIFI_DEBUGFS 598 struct { 599 u32 override; /* u32 for debugfs_create_bool */ 600 struct iwl_bcast_filter_cmd cmd; 601 } dbgfs_bcast_filtering; 602#endif 603#endif 604 605 /* Internal station */ 606 struct iwl_mvm_int_sta aux_sta; 607 608 bool last_ebs_successful; 609 610 u8 scan_last_antenna_idx; /* to toggle TX between antennas */ 611 u8 mgmt_last_antenna_idx; 612 613 /* last smart fifo state that was successfully sent to firmware */ 614 enum iwl_sf_state sf_state; 615 616#ifdef CONFIG_IWLWIFI_DEBUGFS 617 struct dentry *debugfs_dir; 618 u32 dbgfs_sram_offset, dbgfs_sram_len; 619 u32 dbgfs_prph_reg_addr; 620 bool disable_power_off; 621 bool disable_power_off_d3; 622 623 struct debugfs_blob_wrapper nvm_hw_blob; 624 struct debugfs_blob_wrapper nvm_sw_blob; 625 struct debugfs_blob_wrapper nvm_calib_blob; 626 struct debugfs_blob_wrapper nvm_prod_blob; 627 628 struct iwl_mvm_frame_stats drv_rx_stats; 629 spinlock_t drv_stats_lock; 630#endif 631 632 struct iwl_mvm_phy_ctxt phy_ctxts[NUM_PHY_CTX]; 633 634 struct list_head time_event_list; 635 spinlock_t time_event_lock; 636 637 /* 638 * A bitmap indicating the index of the key in use. The firmware 639 * can hold 16 keys at most. Reflect this fact. 640 */ 641 unsigned long fw_key_table[BITS_TO_LONGS(STA_KEY_MAX_NUM)]; 642 643 /* references taken by the driver and spinlock protecting them */ 644 spinlock_t refs_lock; 645 u8 refs[IWL_MVM_REF_COUNT]; 646 647 u8 vif_count; 648 649 /* -1 for always, 0 for never, >0 for that many times */ 650 s8 restart_fw; 651 struct work_struct fw_error_dump_wk; 652 struct iwl_mvm_dump_ptrs *fw_error_dump; 653 654#ifdef CONFIG_IWLWIFI_LEDS 655 struct led_classdev led; 656#endif 657 658 struct ieee80211_vif *p2p_device_vif; 659 660#ifdef CONFIG_PM_SLEEP 661 struct wiphy_wowlan_support wowlan; 662 int gtk_ivlen, gtk_icvlen, ptk_ivlen, ptk_icvlen; 663#ifdef CONFIG_IWLWIFI_DEBUGFS 664 u32 d3_wake_sysassert; /* must be u32 for debugfs_create_bool */ 665 bool d3_test_active; 666 bool store_d3_resume_sram; 667 void *d3_resume_sram; 668 u32 d3_test_pme_ptr; 669 struct ieee80211_vif *keep_vif; 670#endif 671#endif 672 673 /* d0i3 */ 674 u8 d0i3_ap_sta_id; 675 bool d0i3_offloading; 676 struct work_struct d0i3_exit_work; 677 struct sk_buff_head d0i3_tx; 678 /* protect d0i3_suspend_flags */ 679 struct mutex d0i3_suspend_mutex; 680 unsigned long d0i3_suspend_flags; 681 /* sync d0i3_tx queue and IWL_MVM_STATUS_IN_D0I3 status flag */ 682 spinlock_t d0i3_tx_lock; 683 wait_queue_head_t d0i3_exit_waitq; 684 685 /* BT-Coex */ 686 u8 bt_ack_kill_msk[NUM_PHY_CTX]; 687 u8 bt_cts_kill_msk[NUM_PHY_CTX]; 688 689 struct iwl_bt_coex_profile_notif_old last_bt_notif_old; 690 struct iwl_bt_coex_ci_cmd_old last_bt_ci_cmd_old; 691 struct iwl_bt_coex_profile_notif last_bt_notif; 692 struct iwl_bt_coex_ci_cmd last_bt_ci_cmd; 693 694 u32 last_ant_isol; 695 u8 last_corun_lut; 696 u8 bt_tx_prio; 697 enum iwl_bt_force_ant_mode bt_force_ant_mode; 698 699 /* Aux ROC */ 700 struct list_head aux_roc_te_list; 701 702 /* Thermal Throttling and CTkill */ 703 struct iwl_mvm_tt_mgmt thermal_throttle; 704 s32 temperature; /* Celsius */ 705 /* 706 * Debug option to set the NIC temperature. This option makes the 707 * driver think this is the actual NIC temperature, and ignore the 708 * real temperature that is received from the fw 709 */ 710 bool temperature_test; /* Debug test temperature is enabled */ 711 712 struct iwl_time_quota_cmd last_quota_cmd; 713 714#ifdef CONFIG_NL80211_TESTMODE 715 u32 noa_duration; 716 struct ieee80211_vif *noa_vif; 717#endif 718 719 /* Tx queues */ 720 u8 aux_queue; 721 u8 first_agg_queue; 722 u8 last_agg_queue; 723 724 /* Indicate if device power save is allowed */ 725 u8 ps_disabled; /* u8 instead of bool to ease debugfs_create_* usage */ 726 727 struct ieee80211_vif __rcu *csa_vif; 728 struct ieee80211_vif __rcu *csa_tx_blocked_vif; 729 u8 csa_tx_block_bcn_timeout; 730 731 /* system time of last beacon (for AP/GO interface) */ 732 u32 ap_last_beacon_gp2; 733 734 u8 low_latency_agg_frame_limit; 735}; 736 737/* Extract MVM priv from op_mode and _hw */ 738#define IWL_OP_MODE_GET_MVM(_iwl_op_mode) \ 739 ((struct iwl_mvm *)(_iwl_op_mode)->op_mode_specific) 740 741#define IWL_MAC80211_GET_MVM(_hw) \ 742 IWL_OP_MODE_GET_MVM((struct iwl_op_mode *)((_hw)->priv)) 743 744enum iwl_mvm_status { 745 IWL_MVM_STATUS_HW_RFKILL, 746 IWL_MVM_STATUS_HW_CTKILL, 747 IWL_MVM_STATUS_ROC_RUNNING, 748 IWL_MVM_STATUS_IN_HW_RESTART, 749 IWL_MVM_STATUS_IN_D0I3, 750 IWL_MVM_STATUS_ROC_AUX_RUNNING, 751}; 752 753static inline bool iwl_mvm_is_radio_killed(struct iwl_mvm *mvm) 754{ 755 return test_bit(IWL_MVM_STATUS_HW_RFKILL, &mvm->status) || 756 test_bit(IWL_MVM_STATUS_HW_CTKILL, &mvm->status); 757} 758 759static inline struct iwl_mvm_sta * 760iwl_mvm_sta_from_staid_protected(struct iwl_mvm *mvm, u8 sta_id) 761{ 762 struct ieee80211_sta *sta; 763 764 if (sta_id >= ARRAY_SIZE(mvm->fw_id_to_mac_id)) 765 return NULL; 766 767 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id], 768 lockdep_is_held(&mvm->mutex)); 769 770 /* This can happen if the station has been removed right now */ 771 if (IS_ERR_OR_NULL(sta)) 772 return NULL; 773 774 return iwl_mvm_sta_from_mac80211(sta); 775} 776 777static inline bool iwl_mvm_is_d0i3_supported(struct iwl_mvm *mvm) 778{ 779 return mvm->trans->cfg->d0i3 && 780 (mvm->fw->ucode_capa.capa[0] & IWL_UCODE_TLV_CAPA_D0I3_SUPPORT); 781} 782 783static inline bool iwl_mvm_is_dqa_supported(struct iwl_mvm *mvm) 784{ 785 return mvm->fw->ucode_capa.capa[0] & IWL_UCODE_TLV_CAPA_DQA_SUPPORT; 786} 787 788extern const u8 iwl_mvm_ac_to_tx_fifo[]; 789 790struct iwl_rate_info { 791 u8 plcp; /* uCode API: IWL_RATE_6M_PLCP, etc. */ 792 u8 plcp_siso; /* uCode API: IWL_RATE_SISO_6M_PLCP, etc. */ 793 u8 plcp_mimo2; /* uCode API: IWL_RATE_MIMO2_6M_PLCP, etc. */ 794 u8 plcp_mimo3; /* uCode API: IWL_RATE_MIMO3_6M_PLCP, etc. */ 795 u8 ieee; /* MAC header: IWL_RATE_6M_IEEE, etc. */ 796}; 797 798void __iwl_mvm_mac_stop(struct iwl_mvm *mvm); 799int __iwl_mvm_mac_start(struct iwl_mvm *mvm); 800 801/****************** 802 * MVM Methods 803 ******************/ 804/* uCode */ 805int iwl_run_init_mvm_ucode(struct iwl_mvm *mvm, bool read_nvm); 806 807/* Utils */ 808int iwl_mvm_legacy_rate_to_mac80211_idx(u32 rate_n_flags, 809 enum ieee80211_band band); 810void iwl_mvm_hwrate_to_tx_rate(u32 rate_n_flags, 811 enum ieee80211_band band, 812 struct ieee80211_tx_rate *r); 813u8 iwl_mvm_mac80211_idx_to_hwrate(int rate_idx); 814void iwl_mvm_dump_nic_error_log(struct iwl_mvm *mvm); 815u8 first_antenna(u8 mask); 816u8 iwl_mvm_next_antenna(struct iwl_mvm *mvm, u8 valid, u8 last_idx); 817 818/* Tx / Host Commands */ 819int __must_check iwl_mvm_send_cmd(struct iwl_mvm *mvm, 820 struct iwl_host_cmd *cmd); 821int __must_check iwl_mvm_send_cmd_pdu(struct iwl_mvm *mvm, u8 id, 822 u32 flags, u16 len, const void *data); 823int __must_check iwl_mvm_send_cmd_status(struct iwl_mvm *mvm, 824 struct iwl_host_cmd *cmd, 825 u32 *status); 826int __must_check iwl_mvm_send_cmd_pdu_status(struct iwl_mvm *mvm, u8 id, 827 u16 len, const void *data, 828 u32 *status); 829int iwl_mvm_tx_skb(struct iwl_mvm *mvm, struct sk_buff *skb, 830 struct ieee80211_sta *sta); 831int iwl_mvm_tx_skb_non_sta(struct iwl_mvm *mvm, struct sk_buff *skb); 832#ifdef CONFIG_IWLWIFI_DEBUG 833const char *iwl_mvm_get_tx_fail_reason(u32 status); 834#else 835static inline const char *iwl_mvm_get_tx_fail_reason(u32 status) { return ""; } 836#endif 837int iwl_mvm_flush_tx_path(struct iwl_mvm *mvm, u32 tfd_msk, bool sync); 838void iwl_mvm_async_handlers_purge(struct iwl_mvm *mvm); 839 840static inline void iwl_mvm_wait_for_async_handlers(struct iwl_mvm *mvm) 841{ 842 flush_work(&mvm->async_handlers_wk); 843} 844 845/* Statistics */ 846int iwl_mvm_rx_reply_statistics(struct iwl_mvm *mvm, 847 struct iwl_rx_cmd_buffer *rxb, 848 struct iwl_device_cmd *cmd); 849int iwl_mvm_rx_statistics(struct iwl_mvm *mvm, 850 struct iwl_rx_cmd_buffer *rxb, 851 struct iwl_device_cmd *cmd); 852 853/* NVM */ 854int iwl_nvm_init(struct iwl_mvm *mvm, bool read_nvm_from_nic); 855int iwl_mvm_load_nvm_to_nic(struct iwl_mvm *mvm); 856 857int iwl_mvm_up(struct iwl_mvm *mvm); 858int iwl_mvm_load_d3_fw(struct iwl_mvm *mvm); 859 860int iwl_mvm_mac_setup_register(struct iwl_mvm *mvm); 861bool iwl_mvm_bcast_filter_build_cmd(struct iwl_mvm *mvm, 862 struct iwl_bcast_filter_cmd *cmd); 863 864/* 865 * FW notifications / CMD responses handlers 866 * Convention: iwl_mvm_rx_<NAME OF THE CMD> 867 */ 868int iwl_mvm_rx_rx_phy_cmd(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb, 869 struct iwl_device_cmd *cmd); 870int iwl_mvm_rx_rx_mpdu(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb, 871 struct iwl_device_cmd *cmd); 872int iwl_mvm_rx_tx_cmd(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb, 873 struct iwl_device_cmd *cmd); 874int iwl_mvm_rx_ba_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb, 875 struct iwl_device_cmd *cmd); 876int iwl_mvm_rx_radio_ver(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb, 877 struct iwl_device_cmd *cmd); 878int iwl_mvm_rx_ant_coupling_notif(struct iwl_mvm *mvm, 879 struct iwl_rx_cmd_buffer *rxb, 880 struct iwl_device_cmd *cmd); 881int iwl_mvm_rx_fw_error(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb, 882 struct iwl_device_cmd *cmd); 883int iwl_mvm_rx_card_state_notif(struct iwl_mvm *mvm, 884 struct iwl_rx_cmd_buffer *rxb, 885 struct iwl_device_cmd *cmd); 886int iwl_mvm_rx_radio_ver(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb, 887 struct iwl_device_cmd *cmd); 888 889/* MVM PHY */ 890int iwl_mvm_phy_ctxt_add(struct iwl_mvm *mvm, struct iwl_mvm_phy_ctxt *ctxt, 891 struct cfg80211_chan_def *chandef, 892 u8 chains_static, u8 chains_dynamic); 893int iwl_mvm_phy_ctxt_changed(struct iwl_mvm *mvm, struct iwl_mvm_phy_ctxt *ctxt, 894 struct cfg80211_chan_def *chandef, 895 u8 chains_static, u8 chains_dynamic); 896void iwl_mvm_phy_ctxt_ref(struct iwl_mvm *mvm, 897 struct iwl_mvm_phy_ctxt *ctxt); 898void iwl_mvm_phy_ctxt_unref(struct iwl_mvm *mvm, 899 struct iwl_mvm_phy_ctxt *ctxt); 900int iwl_mvm_phy_ctx_count(struct iwl_mvm *mvm); 901 902/* MAC (virtual interface) programming */ 903int iwl_mvm_mac_ctxt_init(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 904void iwl_mvm_mac_ctxt_release(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 905int iwl_mvm_mac_ctxt_add(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 906int iwl_mvm_mac_ctxt_changed(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 907 bool force_assoc_off, const u8 *bssid_override); 908int iwl_mvm_mac_ctxt_remove(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 909u32 iwl_mvm_mac_get_queues_mask(struct iwl_mvm *mvm, 910 struct ieee80211_vif *vif); 911int iwl_mvm_mac_ctxt_beacon_changed(struct iwl_mvm *mvm, 912 struct ieee80211_vif *vif); 913int iwl_mvm_rx_beacon_notif(struct iwl_mvm *mvm, 914 struct iwl_rx_cmd_buffer *rxb, 915 struct iwl_device_cmd *cmd); 916int iwl_mvm_rx_missed_beacons_notif(struct iwl_mvm *mvm, 917 struct iwl_rx_cmd_buffer *rxb, 918 struct iwl_device_cmd *cmd); 919void iwl_mvm_mac_ctxt_recalc_tsf_id(struct iwl_mvm *mvm, 920 struct ieee80211_vif *vif); 921 922/* Bindings */ 923int iwl_mvm_binding_add_vif(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 924int iwl_mvm_binding_remove_vif(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 925 926/* Quota management */ 927int iwl_mvm_update_quotas(struct iwl_mvm *mvm, 928 struct ieee80211_vif *disabled_vif); 929 930/* Scanning */ 931int iwl_mvm_scan_request(struct iwl_mvm *mvm, 932 struct ieee80211_vif *vif, 933 struct cfg80211_scan_request *req); 934int iwl_mvm_rx_scan_response(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb, 935 struct iwl_device_cmd *cmd); 936int iwl_mvm_rx_scan_complete(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb, 937 struct iwl_device_cmd *cmd); 938int iwl_mvm_cancel_scan(struct iwl_mvm *mvm); 939int iwl_mvm_max_scan_ie_len(struct iwl_mvm *mvm, bool is_sched_scan); 940 941/* Scheduled scan */ 942int iwl_mvm_rx_scan_offload_complete_notif(struct iwl_mvm *mvm, 943 struct iwl_rx_cmd_buffer *rxb, 944 struct iwl_device_cmd *cmd); 945int iwl_mvm_config_sched_scan(struct iwl_mvm *mvm, 946 struct ieee80211_vif *vif, 947 struct cfg80211_sched_scan_request *req, 948 struct ieee80211_scan_ies *ies); 949int iwl_mvm_config_sched_scan_profiles(struct iwl_mvm *mvm, 950 struct cfg80211_sched_scan_request *req); 951int iwl_mvm_sched_scan_start(struct iwl_mvm *mvm, 952 struct cfg80211_sched_scan_request *req); 953int iwl_mvm_scan_offload_stop(struct iwl_mvm *mvm, bool notify); 954int iwl_mvm_rx_scan_offload_results(struct iwl_mvm *mvm, 955 struct iwl_rx_cmd_buffer *rxb, 956 struct iwl_device_cmd *cmd); 957 958/* Unified scan */ 959int iwl_mvm_unified_scan_lmac(struct iwl_mvm *mvm, 960 struct ieee80211_vif *vif, 961 struct ieee80211_scan_request *req); 962int iwl_mvm_unified_sched_scan_lmac(struct iwl_mvm *mvm, 963 struct ieee80211_vif *vif, 964 struct cfg80211_sched_scan_request *req, 965 struct ieee80211_scan_ies *ies); 966 967/* MVM debugfs */ 968#ifdef CONFIG_IWLWIFI_DEBUGFS 969int iwl_mvm_dbgfs_register(struct iwl_mvm *mvm, struct dentry *dbgfs_dir); 970void iwl_mvm_vif_dbgfs_register(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 971void iwl_mvm_vif_dbgfs_clean(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 972#else 973static inline int iwl_mvm_dbgfs_register(struct iwl_mvm *mvm, 974 struct dentry *dbgfs_dir) 975{ 976 return 0; 977} 978static inline void 979iwl_mvm_vif_dbgfs_register(struct iwl_mvm *mvm, struct ieee80211_vif *vif) 980{ 981} 982static inline void 983iwl_mvm_vif_dbgfs_clean(struct iwl_mvm *mvm, struct ieee80211_vif *vif) 984{ 985} 986#endif /* CONFIG_IWLWIFI_DEBUGFS */ 987 988/* rate scaling */ 989int iwl_mvm_send_lq_cmd(struct iwl_mvm *mvm, struct iwl_lq_cmd *lq, bool init); 990void iwl_mvm_update_frame_stats(struct iwl_mvm *mvm, 991 struct iwl_mvm_frame_stats *stats, 992 u32 rate, bool agg); 993int rs_pretty_print_rate(char *buf, const u32 rate); 994void rs_update_last_rssi(struct iwl_mvm *mvm, 995 struct iwl_lq_sta *lq_sta, 996 struct ieee80211_rx_status *rx_status); 997 998/* power management */ 999int iwl_mvm_power_update_device(struct iwl_mvm *mvm); 1000int iwl_mvm_power_update_mac(struct iwl_mvm *mvm); 1001int iwl_mvm_power_update_ps(struct iwl_mvm *mvm); 1002int iwl_mvm_power_mac_dbgfs_read(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1003 char *buf, int bufsz); 1004 1005void iwl_mvm_power_vif_assoc(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1006int iwl_mvm_power_uapsd_misbehaving_ap_notif(struct iwl_mvm *mvm, 1007 struct iwl_rx_cmd_buffer *rxb, 1008 struct iwl_device_cmd *cmd); 1009 1010#ifdef CONFIG_IWLWIFI_LEDS 1011int iwl_mvm_leds_init(struct iwl_mvm *mvm); 1012void iwl_mvm_leds_exit(struct iwl_mvm *mvm); 1013#else 1014static inline int iwl_mvm_leds_init(struct iwl_mvm *mvm) 1015{ 1016 return 0; 1017} 1018static inline void iwl_mvm_leds_exit(struct iwl_mvm *mvm) 1019{ 1020} 1021#endif 1022 1023/* D3 (WoWLAN, NetDetect) */ 1024int iwl_mvm_suspend(struct ieee80211_hw *hw, struct cfg80211_wowlan *wowlan); 1025int iwl_mvm_resume(struct ieee80211_hw *hw); 1026void iwl_mvm_set_wakeup(struct ieee80211_hw *hw, bool enabled); 1027void iwl_mvm_set_rekey_data(struct ieee80211_hw *hw, 1028 struct ieee80211_vif *vif, 1029 struct cfg80211_gtk_rekey_data *data); 1030void iwl_mvm_ipv6_addr_change(struct ieee80211_hw *hw, 1031 struct ieee80211_vif *vif, 1032 struct inet6_dev *idev); 1033void iwl_mvm_set_default_unicast_key(struct ieee80211_hw *hw, 1034 struct ieee80211_vif *vif, int idx); 1035extern const struct file_operations iwl_dbgfs_d3_test_ops; 1036#ifdef CONFIG_PM_SLEEP 1037void iwl_mvm_set_last_nonqos_seq(struct iwl_mvm *mvm, 1038 struct ieee80211_vif *vif); 1039#else 1040static inline void 1041iwl_mvm_set_last_nonqos_seq(struct iwl_mvm *mvm, struct ieee80211_vif *vif) 1042{ 1043} 1044#endif 1045void iwl_mvm_set_wowlan_qos_seq(struct iwl_mvm_sta *mvm_ap_sta, 1046 struct iwl_wowlan_config_cmd_v2 *cmd); 1047int iwl_mvm_send_proto_offload(struct iwl_mvm *mvm, 1048 struct ieee80211_vif *vif, 1049 bool disable_offloading, 1050 u32 cmd_flags); 1051 1052/* D0i3 */ 1053void iwl_mvm_ref(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type); 1054void iwl_mvm_unref(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type); 1055int iwl_mvm_ref_sync(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type); 1056void iwl_mvm_d0i3_enable_tx(struct iwl_mvm *mvm, __le16 *qos_seq); 1057int _iwl_mvm_exit_d0i3(struct iwl_mvm *mvm); 1058 1059/* BT Coex */ 1060int iwl_send_bt_init_conf(struct iwl_mvm *mvm); 1061int iwl_mvm_rx_bt_coex_notif(struct iwl_mvm *mvm, 1062 struct iwl_rx_cmd_buffer *rxb, 1063 struct iwl_device_cmd *cmd); 1064void iwl_mvm_bt_rssi_event(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1065 enum ieee80211_rssi_event rssi_event); 1066void iwl_mvm_bt_coex_vif_change(struct iwl_mvm *mvm); 1067u16 iwl_mvm_coex_agg_time_limit(struct iwl_mvm *mvm, 1068 struct ieee80211_sta *sta); 1069bool iwl_mvm_bt_coex_is_mimo_allowed(struct iwl_mvm *mvm, 1070 struct ieee80211_sta *sta); 1071bool iwl_mvm_bt_coex_is_shared_ant_avail(struct iwl_mvm *mvm); 1072bool iwl_mvm_bt_coex_is_tpc_allowed(struct iwl_mvm *mvm, 1073 enum ieee80211_band band); 1074u8 iwl_mvm_bt_coex_tx_prio(struct iwl_mvm *mvm, struct ieee80211_hdr *hdr, 1075 struct ieee80211_tx_info *info, u8 ac); 1076 1077bool iwl_mvm_bt_coex_is_shared_ant_avail_old(struct iwl_mvm *mvm); 1078void iwl_mvm_bt_coex_vif_change_old(struct iwl_mvm *mvm); 1079int iwl_send_bt_init_conf_old(struct iwl_mvm *mvm); 1080int iwl_mvm_rx_bt_coex_notif_old(struct iwl_mvm *mvm, 1081 struct iwl_rx_cmd_buffer *rxb, 1082 struct iwl_device_cmd *cmd); 1083void iwl_mvm_bt_rssi_event_old(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1084 enum ieee80211_rssi_event rssi_event); 1085u16 iwl_mvm_coex_agg_time_limit_old(struct iwl_mvm *mvm, 1086 struct ieee80211_sta *sta); 1087bool iwl_mvm_bt_coex_is_mimo_allowed_old(struct iwl_mvm *mvm, 1088 struct ieee80211_sta *sta); 1089bool iwl_mvm_bt_coex_is_tpc_allowed_old(struct iwl_mvm *mvm, 1090 enum ieee80211_band band); 1091int iwl_mvm_rx_ant_coupling_notif_old(struct iwl_mvm *mvm, 1092 struct iwl_rx_cmd_buffer *rxb, 1093 struct iwl_device_cmd *cmd); 1094 1095enum iwl_bt_kill_msk { 1096 BT_KILL_MSK_DEFAULT, 1097 BT_KILL_MSK_NEVER, 1098 BT_KILL_MSK_ALWAYS, 1099 BT_KILL_MSK_MAX, 1100}; 1101 1102extern const u8 iwl_bt_ack_kill_msk[BT_MAX_AG][BT_COEX_MAX_LUT]; 1103extern const u8 iwl_bt_cts_kill_msk[BT_MAX_AG][BT_COEX_MAX_LUT]; 1104extern const u32 iwl_bt_ctl_kill_msk[BT_KILL_MSK_MAX]; 1105 1106/* beacon filtering */ 1107#ifdef CONFIG_IWLWIFI_DEBUGFS 1108void 1109iwl_mvm_beacon_filter_debugfs_parameters(struct ieee80211_vif *vif, 1110 struct iwl_beacon_filter_cmd *cmd); 1111#else 1112static inline void 1113iwl_mvm_beacon_filter_debugfs_parameters(struct ieee80211_vif *vif, 1114 struct iwl_beacon_filter_cmd *cmd) 1115{} 1116#endif 1117int iwl_mvm_update_d0i3_power_mode(struct iwl_mvm *mvm, 1118 struct ieee80211_vif *vif, 1119 bool enable, u32 flags); 1120int iwl_mvm_enable_beacon_filter(struct iwl_mvm *mvm, 1121 struct ieee80211_vif *vif, 1122 u32 flags); 1123int iwl_mvm_disable_beacon_filter(struct iwl_mvm *mvm, 1124 struct ieee80211_vif *vif, 1125 u32 flags); 1126/* SMPS */ 1127void iwl_mvm_update_smps(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1128 enum iwl_mvm_smps_type_request req_type, 1129 enum ieee80211_smps_mode smps_request); 1130bool iwl_mvm_rx_diversity_allowed(struct iwl_mvm *mvm); 1131 1132/* Low latency */ 1133int iwl_mvm_update_low_latency(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1134 bool value); 1135/* get SystemLowLatencyMode - only needed for beacon threshold? */ 1136bool iwl_mvm_low_latency(struct iwl_mvm *mvm); 1137/* get VMACLowLatencyMode */ 1138static inline bool iwl_mvm_vif_low_latency(struct iwl_mvm_vif *mvmvif) 1139{ 1140 /* 1141 * should this consider associated/active/... state? 1142 * 1143 * Normally low-latency should only be active on interfaces 1144 * that are active, but at least with debugfs it can also be 1145 * enabled on interfaces that aren't active. However, when 1146 * interface aren't active then they aren't added into the 1147 * binding, so this has no real impact. For now, just return 1148 * the current desired low-latency state. 1149 */ 1150 1151 return mvmvif->low_latency; 1152} 1153 1154/* hw scheduler queue config */ 1155void iwl_mvm_enable_txq(struct iwl_mvm *mvm, int queue, u16 ssn, 1156 const struct iwl_trans_txq_scd_cfg *cfg); 1157void iwl_mvm_disable_txq(struct iwl_mvm *mvm, int queue); 1158 1159static inline void iwl_mvm_enable_ac_txq(struct iwl_mvm *mvm, int queue, 1160 u8 fifo) 1161{ 1162 struct iwl_trans_txq_scd_cfg cfg = { 1163 .fifo = fifo, 1164 .tid = IWL_MAX_TID_COUNT, 1165 .aggregate = false, 1166 .frame_limit = IWL_FRAME_LIMIT, 1167 }; 1168 1169 iwl_mvm_enable_txq(mvm, queue, 0, &cfg); 1170} 1171 1172static inline void iwl_mvm_enable_agg_txq(struct iwl_mvm *mvm, int queue, 1173 int fifo, int sta_id, int tid, 1174 int frame_limit, u16 ssn) 1175{ 1176 struct iwl_trans_txq_scd_cfg cfg = { 1177 .fifo = fifo, 1178 .sta_id = sta_id, 1179 .tid = tid, 1180 .frame_limit = frame_limit, 1181 .aggregate = true, 1182 }; 1183 1184 iwl_mvm_enable_txq(mvm, queue, ssn, &cfg); 1185} 1186 1187/* Assoc status */ 1188bool iwl_mvm_is_idle(struct iwl_mvm *mvm); 1189 1190/* Thermal management and CT-kill */ 1191void iwl_mvm_tt_tx_backoff(struct iwl_mvm *mvm, u32 backoff); 1192void iwl_mvm_tt_handler(struct iwl_mvm *mvm); 1193void iwl_mvm_tt_initialize(struct iwl_mvm *mvm, u32 min_backoff); 1194void iwl_mvm_tt_exit(struct iwl_mvm *mvm); 1195void iwl_mvm_set_hw_ctkill_state(struct iwl_mvm *mvm, bool state); 1196int iwl_mvm_get_temp(struct iwl_mvm *mvm); 1197 1198/* smart fifo */ 1199int iwl_mvm_sf_update(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1200 bool added_vif); 1201 1202/* TDLS */ 1203int iwl_mvm_tdls_sta_count(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1204void iwl_mvm_teardown_tdls_peers(struct iwl_mvm *mvm); 1205void iwl_mvm_recalc_tdls_state(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1206 bool sta_added); 1207void iwl_mvm_mac_mgd_protect_tdls_discover(struct ieee80211_hw *hw, 1208 struct ieee80211_vif *vif); 1209 1210void iwl_mvm_nic_restart(struct iwl_mvm *mvm, bool fw_error); 1211#ifdef CONFIG_IWLWIFI_DEBUGFS 1212void iwl_mvm_fw_error_dump(struct iwl_mvm *mvm); 1213#else 1214static inline void iwl_mvm_fw_error_dump(struct iwl_mvm *mvm) {} 1215#endif 1216 1217#endif /* __IWL_MVM_H__ */ 1218