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 - 2015 Intel Mobile Communications GmbH 10 * Copyright(c) 2016 Intel Deutschland GmbH 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of version 2 of the GNU General Public License as 14 * published by the Free Software Foundation. 15 * 16 * This program is distributed in the hope that it will be useful, but 17 * WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, write to the Free Software 23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, 24 * USA 25 * 26 * The full GNU General Public License is included in this distribution 27 * in the file called COPYING. 28 * 29 * Contact Information: 30 * Intel Linux Wireless <linuxwifi@intel.com> 31 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 32 * 33 * BSD LICENSE 34 * 35 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved. 36 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH 37 * Copyright(c) 2016 Intel Deutschland GmbH 38 * All rights reserved. 39 * 40 * Redistribution and use in source and binary forms, with or without 41 * modification, are permitted provided that the following conditions 42 * are met: 43 * 44 * * Redistributions of source code must retain the above copyright 45 * notice, this list of conditions and the following disclaimer. 46 * * Redistributions in binary form must reproduce the above copyright 47 * notice, this list of conditions and the following disclaimer in 48 * the documentation and/or other materials provided with the 49 * distribution. 50 * * Neither the name Intel Corporation nor the names of its 51 * contributors may be used to endorse or promote products derived 52 * from this software without specific prior written permission. 53 * 54 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 55 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 56 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 57 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 58 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 59 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 60 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 61 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 62 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 63 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 64 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 65 * 66 *****************************************************************************/ 67 68 #ifndef __IWL_MVM_H__ 69 #define __IWL_MVM_H__ 70 71 #include <linux/list.h> 72 #include <linux/spinlock.h> 73 #include <linux/leds.h> 74 #include <linux/in6.h> 75 76 #ifdef CONFIG_THERMAL 77 #include <linux/thermal.h> 78 #endif 79 80 #include "iwl-op-mode.h" 81 #include "iwl-trans.h" 82 #include "iwl-notif-wait.h" 83 #include "iwl-eeprom-parse.h" 84 #include "iwl-fw-file.h" 85 #include "iwl-config.h" 86 #include "sta.h" 87 #include "fw-api.h" 88 #include "constants.h" 89 #include "tof.h" 90 91 #define IWL_MVM_MAX_ADDRESSES 5 92 /* RSSI offset for WkP */ 93 #define IWL_RSSI_OFFSET 50 94 #define IWL_MVM_MISSED_BEACONS_THRESHOLD 8 95 /* A TimeUnit is 1024 microsecond */ 96 #define MSEC_TO_TU(_msec) (_msec*1000/1024) 97 98 /* For GO, this value represents the number of TUs before CSA "beacon 99 * 0" TBTT when the CSA time-event needs to be scheduled to start. It 100 * must be big enough to ensure that we switch in time. 101 */ 102 #define IWL_MVM_CHANNEL_SWITCH_TIME_GO 40 103 104 /* For client, this value represents the number of TUs before CSA 105 * "beacon 1" TBTT, instead. This is because we don't know when the 106 * GO/AP will be in the new channel, so we switch early enough. 107 */ 108 #define IWL_MVM_CHANNEL_SWITCH_TIME_CLIENT 10 109 110 /* 111 * This value (in TUs) is used to fine tune the CSA NoA end time which should 112 * be just before "beacon 0" TBTT. 113 */ 114 #define IWL_MVM_CHANNEL_SWITCH_MARGIN 4 115 116 /* 117 * Number of beacons to transmit on a new channel until we unblock tx to 118 * the stations, even if we didn't identify them on a new channel 119 */ 120 #define IWL_MVM_CS_UNBLOCK_TX_TIMEOUT 3 121 122 extern const struct ieee80211_ops iwl_mvm_hw_ops; 123 124 /** 125 * struct iwl_mvm_mod_params - module parameters for iwlmvm 126 * @init_dbg: if true, then the NIC won't be stopped if the INIT fw asserted. 127 * We will register to mac80211 to have testmode working. The NIC must not 128 * be up'ed after the INIT fw asserted. This is useful to be able to use 129 * proprietary tools over testmode to debug the INIT fw. 130 * @tfd_q_hang_detect: enabled the detection of hung transmit queues 131 * @power_scheme: one of enum iwl_power_scheme 132 */ 133 struct iwl_mvm_mod_params { 134 bool init_dbg; 135 bool tfd_q_hang_detect; 136 int power_scheme; 137 }; 138 extern struct iwl_mvm_mod_params iwlmvm_mod_params; 139 140 /** 141 * struct iwl_mvm_dump_ptrs - set of pointers needed for the fw-error-dump 142 * 143 * @op_mode_ptr: pointer to the buffer coming from the mvm op_mode 144 * @trans_ptr: pointer to struct %iwl_trans_dump_data which contains the 145 * transport's data. 146 * @trans_len: length of the valid data in trans_ptr 147 * @op_mode_len: length of the valid data in op_mode_ptr 148 */ 149 struct iwl_mvm_dump_ptrs { 150 struct iwl_trans_dump_data *trans_ptr; 151 void *op_mode_ptr; 152 u32 op_mode_len; 153 }; 154 155 /** 156 * struct iwl_mvm_dump_desc - describes the dump 157 * @len: length of trig_desc->data 158 * @trig_desc: the description of the dump 159 */ 160 struct iwl_mvm_dump_desc { 161 size_t len; 162 /* must be last */ 163 struct iwl_fw_error_dump_trigger_desc trig_desc; 164 }; 165 166 extern const struct iwl_mvm_dump_desc iwl_mvm_dump_desc_assert; 167 168 struct iwl_mvm_phy_ctxt { 169 u16 id; 170 u16 color; 171 u32 ref; 172 173 /* 174 * TODO: This should probably be removed. Currently here only for rate 175 * scaling algorithm 176 */ 177 struct ieee80211_channel *channel; 178 }; 179 180 struct iwl_mvm_time_event_data { 181 struct ieee80211_vif *vif; 182 struct list_head list; 183 unsigned long end_jiffies; 184 u32 duration; 185 bool running; 186 u32 uid; 187 188 /* 189 * The access to the 'id' field must be done when the 190 * mvm->time_event_lock is held, as it value is used to indicate 191 * if the te is in the time event list or not (when id == TE_MAX) 192 */ 193 u32 id; 194 }; 195 196 /* Power management */ 197 198 /** 199 * enum iwl_power_scheme 200 * @IWL_POWER_LEVEL_CAM - Continuously Active Mode 201 * @IWL_POWER_LEVEL_BPS - Balanced Power Save (default) 202 * @IWL_POWER_LEVEL_LP - Low Power 203 */ 204 enum iwl_power_scheme { 205 IWL_POWER_SCHEME_CAM = 1, 206 IWL_POWER_SCHEME_BPS, 207 IWL_POWER_SCHEME_LP 208 }; 209 210 #define IWL_CONN_MAX_LISTEN_INTERVAL 10 211 #define IWL_UAPSD_MAX_SP IEEE80211_WMM_IE_STA_QOSINFO_SP_2 212 213 #ifdef CONFIG_IWLWIFI_DEBUGFS 214 enum iwl_dbgfs_pm_mask { 215 MVM_DEBUGFS_PM_KEEP_ALIVE = BIT(0), 216 MVM_DEBUGFS_PM_SKIP_OVER_DTIM = BIT(1), 217 MVM_DEBUGFS_PM_SKIP_DTIM_PERIODS = BIT(2), 218 MVM_DEBUGFS_PM_RX_DATA_TIMEOUT = BIT(3), 219 MVM_DEBUGFS_PM_TX_DATA_TIMEOUT = BIT(4), 220 MVM_DEBUGFS_PM_LPRX_ENA = BIT(6), 221 MVM_DEBUGFS_PM_LPRX_RSSI_THRESHOLD = BIT(7), 222 MVM_DEBUGFS_PM_SNOOZE_ENABLE = BIT(8), 223 MVM_DEBUGFS_PM_UAPSD_MISBEHAVING = BIT(9), 224 MVM_DEBUGFS_PM_USE_PS_POLL = BIT(10), 225 }; 226 227 struct iwl_dbgfs_pm { 228 u16 keep_alive_seconds; 229 u32 rx_data_timeout; 230 u32 tx_data_timeout; 231 bool skip_over_dtim; 232 u8 skip_dtim_periods; 233 bool lprx_ena; 234 u32 lprx_rssi_threshold; 235 bool snooze_ena; 236 bool uapsd_misbehaving; 237 bool use_ps_poll; 238 int mask; 239 }; 240 241 /* beacon filtering */ 242 243 enum iwl_dbgfs_bf_mask { 244 MVM_DEBUGFS_BF_ENERGY_DELTA = BIT(0), 245 MVM_DEBUGFS_BF_ROAMING_ENERGY_DELTA = BIT(1), 246 MVM_DEBUGFS_BF_ROAMING_STATE = BIT(2), 247 MVM_DEBUGFS_BF_TEMP_THRESHOLD = BIT(3), 248 MVM_DEBUGFS_BF_TEMP_FAST_FILTER = BIT(4), 249 MVM_DEBUGFS_BF_TEMP_SLOW_FILTER = BIT(5), 250 MVM_DEBUGFS_BF_ENABLE_BEACON_FILTER = BIT(6), 251 MVM_DEBUGFS_BF_DEBUG_FLAG = BIT(7), 252 MVM_DEBUGFS_BF_ESCAPE_TIMER = BIT(8), 253 MVM_DEBUGFS_BA_ESCAPE_TIMER = BIT(9), 254 MVM_DEBUGFS_BA_ENABLE_BEACON_ABORT = BIT(10), 255 }; 256 257 struct iwl_dbgfs_bf { 258 u32 bf_energy_delta; 259 u32 bf_roaming_energy_delta; 260 u32 bf_roaming_state; 261 u32 bf_temp_threshold; 262 u32 bf_temp_fast_filter; 263 u32 bf_temp_slow_filter; 264 u32 bf_enable_beacon_filter; 265 u32 bf_debug_flag; 266 u32 bf_escape_timer; 267 u32 ba_escape_timer; 268 u32 ba_enable_beacon_abort; 269 int mask; 270 }; 271 #endif 272 273 enum iwl_mvm_smps_type_request { 274 IWL_MVM_SMPS_REQ_BT_COEX, 275 IWL_MVM_SMPS_REQ_TT, 276 IWL_MVM_SMPS_REQ_PROT, 277 NUM_IWL_MVM_SMPS_REQ, 278 }; 279 280 enum iwl_mvm_ref_type { 281 IWL_MVM_REF_UCODE_DOWN, 282 IWL_MVM_REF_SCAN, 283 IWL_MVM_REF_ROC, 284 IWL_MVM_REF_ROC_AUX, 285 IWL_MVM_REF_P2P_CLIENT, 286 IWL_MVM_REF_AP_IBSS, 287 IWL_MVM_REF_USER, 288 IWL_MVM_REF_TX, 289 IWL_MVM_REF_TX_AGG, 290 IWL_MVM_REF_ADD_IF, 291 IWL_MVM_REF_START_AP, 292 IWL_MVM_REF_BSS_CHANGED, 293 IWL_MVM_REF_PREPARE_TX, 294 IWL_MVM_REF_PROTECT_TDLS, 295 IWL_MVM_REF_CHECK_CTKILL, 296 IWL_MVM_REF_PRPH_READ, 297 IWL_MVM_REF_PRPH_WRITE, 298 IWL_MVM_REF_NMI, 299 IWL_MVM_REF_TM_CMD, 300 IWL_MVM_REF_EXIT_WORK, 301 IWL_MVM_REF_PROTECT_CSA, 302 IWL_MVM_REF_FW_DBG_COLLECT, 303 IWL_MVM_REF_INIT_UCODE, 304 305 /* update debugfs.c when changing this */ 306 307 IWL_MVM_REF_COUNT, 308 }; 309 310 enum iwl_bt_force_ant_mode { 311 BT_FORCE_ANT_DIS = 0, 312 BT_FORCE_ANT_AUTO, 313 BT_FORCE_ANT_BT, 314 BT_FORCE_ANT_WIFI, 315 316 BT_FORCE_ANT_MAX, 317 }; 318 319 /** 320 * struct iwl_mvm_vif_bf_data - beacon filtering related data 321 * @bf_enabled: indicates if beacon filtering is enabled 322 * @ba_enabled: indicated if beacon abort is enabled 323 * @ave_beacon_signal: average beacon signal 324 * @last_cqm_event: rssi of the last cqm event 325 * @bt_coex_min_thold: minimum threshold for BT coex 326 * @bt_coex_max_thold: maximum threshold for BT coex 327 * @last_bt_coex_event: rssi of the last BT coex event 328 */ 329 struct iwl_mvm_vif_bf_data { 330 bool bf_enabled; 331 bool ba_enabled; 332 int ave_beacon_signal; 333 int last_cqm_event; 334 int bt_coex_min_thold; 335 int bt_coex_max_thold; 336 int last_bt_coex_event; 337 }; 338 339 /** 340 * struct iwl_mvm_vif - data per Virtual Interface, it is a MAC context 341 * @id: between 0 and 3 342 * @color: to solve races upon MAC addition and removal 343 * @ap_sta_id: the sta_id of the AP - valid only if VIF type is STA 344 * @bssid: BSSID for this (client) interface 345 * @associated: indicates that we're currently associated, used only for 346 * managing the firmware state in iwl_mvm_bss_info_changed_station() 347 * @ap_assoc_sta_count: count of stations associated to us - valid only 348 * if VIF type is AP 349 * @uploaded: indicates the MAC context has been added to the device 350 * @ap_ibss_active: indicates that AP/IBSS is configured and that the interface 351 * should get quota etc. 352 * @pm_enabled - Indicate if MAC power management is allowed 353 * @monitor_active: indicates that monitor context is configured, and that the 354 * interface should get quota etc. 355 * @low_latency_traffic: indicates low latency traffic was detected 356 * @low_latency_dbgfs: low latency mode set from debugfs 357 * @low_latency_vcmd: low latency mode set from vendor command 358 * @ps_disabled: indicates that this interface requires PS to be disabled 359 * @queue_params: QoS params for this MAC 360 * @bcast_sta: station used for broadcast packets. Used by the following 361 * vifs: P2P_DEVICE, GO and AP. 362 * @beacon_skb: the skb used to hold the AP/GO beacon template 363 * @smps_requests: the SMPS requests of different parts of the driver, 364 * combined on update to yield the overall request to mac80211. 365 * @beacon_stats: beacon statistics, containing the # of received beacons, 366 * # of received beacons accumulated over FW restart, and the current 367 * average signal of beacons retrieved from the firmware 368 * @csa_failed: CSA failed to schedule time event, report an error later 369 * @features: hw features active for this vif 370 */ 371 struct iwl_mvm_vif { 372 struct iwl_mvm *mvm; 373 u16 id; 374 u16 color; 375 u8 ap_sta_id; 376 377 u8 bssid[ETH_ALEN]; 378 bool associated; 379 u8 ap_assoc_sta_count; 380 381 bool uploaded; 382 bool ap_ibss_active; 383 bool pm_enabled; 384 bool monitor_active; 385 bool low_latency_traffic, low_latency_dbgfs, low_latency_vcmd; 386 bool ps_disabled; 387 struct iwl_mvm_vif_bf_data bf_data; 388 389 struct { 390 u32 num_beacons, accu_num_beacons; 391 u8 avg_signal; 392 } beacon_stats; 393 394 u32 ap_beacon_time; 395 396 enum iwl_tsf_id tsf_id; 397 398 /* 399 * QoS data from mac80211, need to store this here 400 * as mac80211 has a separate callback but we need 401 * to have the data for the MAC context 402 */ 403 struct ieee80211_tx_queue_params queue_params[IEEE80211_NUM_ACS]; 404 struct iwl_mvm_time_event_data time_event_data; 405 struct iwl_mvm_time_event_data hs_time_event_data; 406 407 struct iwl_mvm_int_sta bcast_sta; 408 409 /* 410 * Assigned while mac80211 has the interface in a channel context, 411 * or, for P2P Device, while it exists. 412 */ 413 struct iwl_mvm_phy_ctxt *phy_ctxt; 414 415 #ifdef CONFIG_PM 416 /* WoWLAN GTK rekey data */ 417 struct { 418 u8 kck[NL80211_KCK_LEN], kek[NL80211_KEK_LEN]; 419 __le64 replay_ctr; 420 bool valid; 421 } rekey_data; 422 423 int tx_key_idx; 424 425 bool seqno_valid; 426 u16 seqno; 427 #endif 428 429 #if IS_ENABLED(CONFIG_IPV6) 430 /* IPv6 addresses for WoWLAN */ 431 struct in6_addr target_ipv6_addrs[IWL_PROTO_OFFLOAD_NUM_IPV6_ADDRS_MAX]; 432 unsigned long tentative_addrs[BITS_TO_LONGS(IWL_PROTO_OFFLOAD_NUM_IPV6_ADDRS_MAX)]; 433 int num_target_ipv6_addrs; 434 #endif 435 436 #ifdef CONFIG_IWLWIFI_DEBUGFS 437 struct dentry *dbgfs_dir; 438 struct dentry *dbgfs_slink; 439 struct iwl_dbgfs_pm dbgfs_pm; 440 struct iwl_dbgfs_bf dbgfs_bf; 441 struct iwl_mac_power_cmd mac_pwr_cmd; 442 int dbgfs_quota_min; 443 #endif 444 445 enum ieee80211_smps_mode smps_requests[NUM_IWL_MVM_SMPS_REQ]; 446 447 /* FW identified misbehaving AP */ 448 u8 uapsd_misbehaving_bssid[ETH_ALEN]; 449 450 /* Indicates that CSA countdown may be started */ 451 bool csa_countdown; 452 bool csa_failed; 453 454 /* TCP Checksum Offload */ 455 netdev_features_t features; 456 }; 457 458 static inline struct iwl_mvm_vif * 459 iwl_mvm_vif_from_mac80211(struct ieee80211_vif *vif) 460 { 461 return (void *)vif->drv_priv; 462 } 463 464 extern const u8 tid_to_mac80211_ac[]; 465 466 #define IWL_MVM_SCAN_STOPPING_SHIFT 8 467 468 enum iwl_scan_status { 469 IWL_MVM_SCAN_REGULAR = BIT(0), 470 IWL_MVM_SCAN_SCHED = BIT(1), 471 IWL_MVM_SCAN_NETDETECT = BIT(2), 472 473 IWL_MVM_SCAN_STOPPING_REGULAR = BIT(8), 474 IWL_MVM_SCAN_STOPPING_SCHED = BIT(9), 475 IWL_MVM_SCAN_STOPPING_NETDETECT = BIT(10), 476 477 IWL_MVM_SCAN_REGULAR_MASK = IWL_MVM_SCAN_REGULAR | 478 IWL_MVM_SCAN_STOPPING_REGULAR, 479 IWL_MVM_SCAN_SCHED_MASK = IWL_MVM_SCAN_SCHED | 480 IWL_MVM_SCAN_STOPPING_SCHED, 481 IWL_MVM_SCAN_NETDETECT_MASK = IWL_MVM_SCAN_NETDETECT | 482 IWL_MVM_SCAN_STOPPING_NETDETECT, 483 484 IWL_MVM_SCAN_STOPPING_MASK = 0xff << IWL_MVM_SCAN_STOPPING_SHIFT, 485 IWL_MVM_SCAN_MASK = 0xff, 486 }; 487 488 enum iwl_mvm_scan_type { 489 IWL_SCAN_TYPE_NOT_SET, 490 IWL_SCAN_TYPE_UNASSOC, 491 IWL_SCAN_TYPE_WILD, 492 IWL_SCAN_TYPE_MILD, 493 IWL_SCAN_TYPE_FRAGMENTED, 494 }; 495 496 enum iwl_mvm_sched_scan_pass_all_states { 497 SCHED_SCAN_PASS_ALL_DISABLED, 498 SCHED_SCAN_PASS_ALL_ENABLED, 499 SCHED_SCAN_PASS_ALL_FOUND, 500 }; 501 502 /** 503 * struct iwl_nvm_section - describes an NVM section in memory. 504 * 505 * This struct holds an NVM section read from the NIC using NVM_ACCESS_CMD, 506 * and saved for later use by the driver. Not all NVM sections are saved 507 * this way, only the needed ones. 508 */ 509 struct iwl_nvm_section { 510 u16 length; 511 const u8 *data; 512 }; 513 514 /** 515 * struct iwl_mvm_tt_mgnt - Thermal Throttling Management structure 516 * @ct_kill_exit: worker to exit thermal kill 517 * @dynamic_smps: Is thermal throttling enabled dynamic_smps? 518 * @tx_backoff: The current thremal throttling tx backoff in uSec. 519 * @min_backoff: The minimal tx backoff due to power restrictions 520 * @params: Parameters to configure the thermal throttling algorithm. 521 * @throttle: Is thermal throttling is active? 522 */ 523 struct iwl_mvm_tt_mgmt { 524 struct delayed_work ct_kill_exit; 525 bool dynamic_smps; 526 u32 tx_backoff; 527 u32 min_backoff; 528 struct iwl_tt_params params; 529 bool throttle; 530 }; 531 532 #ifdef CONFIG_THERMAL 533 /** 534 *struct iwl_mvm_thermal_device - thermal zone related data 535 * @temp_trips: temperature thresholds for report 536 * @fw_trips_index: keep indexes to original array - temp_trips 537 * @tzone: thermal zone device data 538 */ 539 struct iwl_mvm_thermal_device { 540 s16 temp_trips[IWL_MAX_DTS_TRIPS]; 541 u8 fw_trips_index[IWL_MAX_DTS_TRIPS]; 542 struct thermal_zone_device *tzone; 543 }; 544 545 /* 546 * struct iwl_mvm_cooling_device 547 * @cur_state: current state 548 * @cdev: struct thermal cooling device 549 */ 550 struct iwl_mvm_cooling_device { 551 u32 cur_state; 552 struct thermal_cooling_device *cdev; 553 }; 554 #endif 555 556 #define IWL_MVM_NUM_LAST_FRAMES_UCODE_RATES 8 557 558 struct iwl_mvm_frame_stats { 559 u32 legacy_frames; 560 u32 ht_frames; 561 u32 vht_frames; 562 u32 bw_20_frames; 563 u32 bw_40_frames; 564 u32 bw_80_frames; 565 u32 bw_160_frames; 566 u32 sgi_frames; 567 u32 ngi_frames; 568 u32 siso_frames; 569 u32 mimo2_frames; 570 u32 agg_frames; 571 u32 ampdu_count; 572 u32 success_frames; 573 u32 fail_frames; 574 u32 last_rates[IWL_MVM_NUM_LAST_FRAMES_UCODE_RATES]; 575 int last_frame_idx; 576 }; 577 578 enum { 579 D0I3_DEFER_WAKEUP, 580 D0I3_PENDING_WAKEUP, 581 }; 582 583 #define IWL_MVM_DEBUG_SET_TEMPERATURE_DISABLE 0xff 584 #define IWL_MVM_DEBUG_SET_TEMPERATURE_MIN -100 585 #define IWL_MVM_DEBUG_SET_TEMPERATURE_MAX 200 586 587 enum iwl_mvm_tdls_cs_state { 588 IWL_MVM_TDLS_SW_IDLE = 0, 589 IWL_MVM_TDLS_SW_REQ_SENT, 590 IWL_MVM_TDLS_SW_RESP_RCVD, 591 IWL_MVM_TDLS_SW_REQ_RCVD, 592 IWL_MVM_TDLS_SW_ACTIVE, 593 }; 594 595 struct iwl_mvm_shared_mem_cfg { 596 u32 shared_mem_addr; 597 u32 shared_mem_size; 598 u32 sample_buff_addr; 599 u32 sample_buff_size; 600 u32 txfifo_addr; 601 u32 txfifo_size[TX_FIFO_MAX_NUM]; 602 u32 rxfifo_size[RX_FIFO_MAX_NUM]; 603 u32 page_buff_addr; 604 u32 page_buff_size; 605 }; 606 607 struct iwl_mvm { 608 /* for logger access */ 609 struct device *dev; 610 611 struct iwl_trans *trans; 612 const struct iwl_fw *fw; 613 const struct iwl_cfg *cfg; 614 struct iwl_phy_db *phy_db; 615 struct ieee80211_hw *hw; 616 617 /* for protecting access to iwl_mvm */ 618 struct mutex mutex; 619 struct list_head async_handlers_list; 620 spinlock_t async_handlers_lock; 621 struct work_struct async_handlers_wk; 622 623 struct work_struct roc_done_wk; 624 625 unsigned long status; 626 627 /* 628 * for beacon filtering - 629 * currently only one interface can be supported 630 */ 631 struct iwl_mvm_vif *bf_allowed_vif; 632 633 enum iwl_ucode_type cur_ucode; 634 bool ucode_loaded; 635 bool calibrating; 636 u32 error_event_table; 637 u32 log_event_table; 638 u32 umac_error_event_table; 639 bool support_umac_log; 640 struct iwl_sf_region sf_space; 641 642 u32 ampdu_ref; 643 644 struct iwl_notif_wait_data notif_wait; 645 646 struct mvm_statistics_rx rx_stats; 647 648 struct { 649 u64 rx_time; 650 u64 tx_time; 651 u64 on_time_rf; 652 u64 on_time_scan; 653 } radio_stats, accu_radio_stats; 654 655 struct { 656 /* Map to HW queue */ 657 u32 hw_queue_to_mac80211; 658 u8 hw_queue_refcount; 659 bool setup_reserved; 660 u16 tid_bitmap; /* Bitmap of the TIDs mapped to this queue */ 661 } queue_info[IWL_MAX_HW_QUEUES]; 662 spinlock_t queue_info_lock; /* For syncing queue mgmt operations */ 663 atomic_t mac80211_queue_stop_count[IEEE80211_MAX_QUEUES]; 664 665 const char *nvm_file_name; 666 struct iwl_nvm_data *nvm_data; 667 /* NVM sections */ 668 struct iwl_nvm_section nvm_sections[NVM_MAX_NUM_SECTIONS]; 669 670 /* Paging section */ 671 struct iwl_fw_paging fw_paging_db[NUM_OF_FW_PAGING_BLOCKS]; 672 u16 num_of_paging_blk; 673 u16 num_of_pages_in_last_blk; 674 675 /* EEPROM MAC addresses */ 676 struct mac_address addresses[IWL_MVM_MAX_ADDRESSES]; 677 678 /* data related to data path */ 679 struct iwl_rx_phy_info last_phy_info; 680 struct ieee80211_sta __rcu *fw_id_to_mac_id[IWL_MVM_STATION_COUNT]; 681 struct work_struct sta_drained_wk; 682 unsigned long sta_drained[BITS_TO_LONGS(IWL_MVM_STATION_COUNT)]; 683 atomic_t pending_frames[IWL_MVM_STATION_COUNT]; 684 u32 tfd_drained[IWL_MVM_STATION_COUNT]; 685 u8 rx_ba_sessions; 686 u32 secret_key[IWL_RSS_HASH_KEY_CNT]; 687 688 /* configured by mac80211 */ 689 u32 rts_threshold; 690 691 /* Scan status, cmd (pre-allocated) and auxiliary station */ 692 unsigned int scan_status; 693 void *scan_cmd; 694 struct iwl_mcast_filter_cmd *mcast_filter_cmd; 695 enum iwl_mvm_scan_type scan_type; 696 enum iwl_mvm_sched_scan_pass_all_states sched_scan_pass_all; 697 698 /* max number of simultaneous scans the FW supports */ 699 unsigned int max_scans; 700 701 /* ts of the beginning of a non-collect fw dbg data period */ 702 unsigned long fw_dbg_non_collect_ts_start[FW_DBG_TRIGGER_MAX - 1]; 703 704 /* UMAC scan tracking */ 705 u32 scan_uid_status[IWL_MVM_MAX_UMAC_SCANS]; 706 707 /* rx chain antennas set through debugfs for the scan command */ 708 u8 scan_rx_ant; 709 710 #ifdef CONFIG_IWLWIFI_BCAST_FILTERING 711 /* broadcast filters to configure for each associated station */ 712 const struct iwl_fw_bcast_filter *bcast_filters; 713 #ifdef CONFIG_IWLWIFI_DEBUGFS 714 struct { 715 bool override; 716 struct iwl_bcast_filter_cmd cmd; 717 } dbgfs_bcast_filtering; 718 #endif 719 #endif 720 721 /* Internal station */ 722 struct iwl_mvm_int_sta aux_sta; 723 struct iwl_mvm_int_sta snif_sta; 724 725 bool last_ebs_successful; 726 727 u8 scan_last_antenna_idx; /* to toggle TX between antennas */ 728 u8 mgmt_last_antenna_idx; 729 730 /* last smart fifo state that was successfully sent to firmware */ 731 enum iwl_sf_state sf_state; 732 733 #ifdef CONFIG_IWLWIFI_DEBUGFS 734 struct dentry *debugfs_dir; 735 u32 dbgfs_sram_offset, dbgfs_sram_len; 736 u32 dbgfs_prph_reg_addr; 737 bool disable_power_off; 738 bool disable_power_off_d3; 739 740 bool scan_iter_notif_enabled; 741 742 struct debugfs_blob_wrapper nvm_hw_blob; 743 struct debugfs_blob_wrapper nvm_sw_blob; 744 struct debugfs_blob_wrapper nvm_calib_blob; 745 struct debugfs_blob_wrapper nvm_prod_blob; 746 struct debugfs_blob_wrapper nvm_phy_sku_blob; 747 748 struct iwl_mvm_frame_stats drv_rx_stats; 749 spinlock_t drv_stats_lock; 750 u16 dbgfs_rx_phyinfo; 751 #endif 752 753 struct iwl_mvm_phy_ctxt phy_ctxts[NUM_PHY_CTX]; 754 755 struct list_head time_event_list; 756 spinlock_t time_event_lock; 757 758 /* 759 * A bitmap indicating the index of the key in use. The firmware 760 * can hold 16 keys at most. Reflect this fact. 761 */ 762 unsigned long fw_key_table[BITS_TO_LONGS(STA_KEY_MAX_NUM)]; 763 u8 fw_key_deleted[STA_KEY_MAX_NUM]; 764 765 /* references taken by the driver and spinlock protecting them */ 766 spinlock_t refs_lock; 767 u8 refs[IWL_MVM_REF_COUNT]; 768 769 u8 vif_count; 770 771 /* -1 for always, 0 for never, >0 for that many times */ 772 s8 restart_fw; 773 u8 fw_dbg_conf; 774 struct delayed_work fw_dump_wk; 775 const struct iwl_mvm_dump_desc *fw_dump_desc; 776 const struct iwl_fw_dbg_trigger_tlv *fw_dump_trig; 777 778 #ifdef CONFIG_IWLWIFI_LEDS 779 struct led_classdev led; 780 #endif 781 782 struct ieee80211_vif *p2p_device_vif; 783 784 #ifdef CONFIG_PM 785 struct wiphy_wowlan_support wowlan; 786 int gtk_ivlen, gtk_icvlen, ptk_ivlen, ptk_icvlen; 787 788 /* sched scan settings for net detect */ 789 struct ieee80211_scan_ies nd_ies; 790 struct cfg80211_match_set *nd_match_sets; 791 int n_nd_match_sets; 792 struct ieee80211_channel **nd_channels; 793 int n_nd_channels; 794 bool net_detect; 795 #ifdef CONFIG_IWLWIFI_DEBUGFS 796 bool d3_wake_sysassert; 797 bool d3_test_active; 798 bool store_d3_resume_sram; 799 void *d3_resume_sram; 800 u32 d3_test_pme_ptr; 801 struct ieee80211_vif *keep_vif; 802 u32 last_netdetect_scans; /* no. of scans in the last net-detect wake */ 803 #endif 804 #endif 805 806 /* d0i3 */ 807 u8 d0i3_ap_sta_id; 808 bool d0i3_offloading; 809 struct work_struct d0i3_exit_work; 810 struct sk_buff_head d0i3_tx; 811 /* protect d0i3_suspend_flags */ 812 struct mutex d0i3_suspend_mutex; 813 unsigned long d0i3_suspend_flags; 814 /* sync d0i3_tx queue and IWL_MVM_STATUS_IN_D0I3 status flag */ 815 spinlock_t d0i3_tx_lock; 816 wait_queue_head_t d0i3_exit_waitq; 817 818 /* BT-Coex */ 819 u8 bt_ack_kill_msk[NUM_PHY_CTX]; 820 u8 bt_cts_kill_msk[NUM_PHY_CTX]; 821 822 struct iwl_bt_coex_profile_notif_old last_bt_notif_old; 823 struct iwl_bt_coex_ci_cmd_old last_bt_ci_cmd_old; 824 struct iwl_bt_coex_profile_notif last_bt_notif; 825 struct iwl_bt_coex_ci_cmd last_bt_ci_cmd; 826 827 u32 last_ant_isol; 828 u8 last_corun_lut; 829 u8 bt_tx_prio; 830 enum iwl_bt_force_ant_mode bt_force_ant_mode; 831 832 /* Aux ROC */ 833 struct list_head aux_roc_te_list; 834 835 /* Thermal Throttling and CTkill */ 836 struct iwl_mvm_tt_mgmt thermal_throttle; 837 #ifdef CONFIG_THERMAL 838 struct iwl_mvm_thermal_device tz_device; 839 struct iwl_mvm_cooling_device cooling_dev; 840 #endif 841 842 s32 temperature; /* Celsius */ 843 /* 844 * Debug option to set the NIC temperature. This option makes the 845 * driver think this is the actual NIC temperature, and ignore the 846 * real temperature that is received from the fw 847 */ 848 bool temperature_test; /* Debug test temperature is enabled */ 849 850 struct iwl_time_quota_cmd last_quota_cmd; 851 852 #ifdef CONFIG_NL80211_TESTMODE 853 u32 noa_duration; 854 struct ieee80211_vif *noa_vif; 855 #endif 856 857 /* Tx queues */ 858 u8 aux_queue; 859 u8 first_agg_queue; 860 u8 last_agg_queue; 861 862 /* Indicate if device power save is allowed */ 863 u8 ps_disabled; /* u8 instead of bool to ease debugfs_create_* usage */ 864 unsigned int max_amsdu_len; /* used for debugfs only */ 865 866 struct ieee80211_vif __rcu *csa_vif; 867 struct ieee80211_vif __rcu *csa_tx_blocked_vif; 868 u8 csa_tx_block_bcn_timeout; 869 870 /* system time of last beacon (for AP/GO interface) */ 871 u32 ap_last_beacon_gp2; 872 873 bool lar_regdom_set; 874 enum iwl_mcc_source mcc_src; 875 876 /* TDLS channel switch data */ 877 struct { 878 struct delayed_work dwork; 879 enum iwl_mvm_tdls_cs_state state; 880 881 /* 882 * Current cs sta - might be different from periodic cs peer 883 * station. Value is meaningless when the cs-state is idle. 884 */ 885 u8 cur_sta_id; 886 887 /* TDLS periodic channel-switch peer */ 888 struct { 889 u8 sta_id; 890 u8 op_class; 891 bool initiator; /* are we the link initiator */ 892 struct cfg80211_chan_def chandef; 893 struct sk_buff *skb; /* ch sw template */ 894 u32 ch_sw_tm_ie; 895 896 /* timestamp of last ch-sw request sent (GP2 time) */ 897 u32 sent_timestamp; 898 } peer; 899 } tdls_cs; 900 901 struct iwl_mvm_shared_mem_cfg shared_mem_cfg; 902 903 u32 ciphers[6]; 904 struct iwl_mvm_tof_data tof_data; 905 906 /* 907 * Drop beacons from other APs in AP mode when there are no connected 908 * clients. 909 */ 910 bool drop_bcn_ap_mode; 911 }; 912 913 /* Extract MVM priv from op_mode and _hw */ 914 #define IWL_OP_MODE_GET_MVM(_iwl_op_mode) \ 915 ((struct iwl_mvm *)(_iwl_op_mode)->op_mode_specific) 916 917 #define IWL_MAC80211_GET_MVM(_hw) \ 918 IWL_OP_MODE_GET_MVM((struct iwl_op_mode *)((_hw)->priv)) 919 920 enum iwl_mvm_status { 921 IWL_MVM_STATUS_HW_RFKILL, 922 IWL_MVM_STATUS_HW_CTKILL, 923 IWL_MVM_STATUS_ROC_RUNNING, 924 IWL_MVM_STATUS_IN_HW_RESTART, 925 IWL_MVM_STATUS_IN_D0I3, 926 IWL_MVM_STATUS_ROC_AUX_RUNNING, 927 IWL_MVM_STATUS_D3_RECONFIG, 928 IWL_MVM_STATUS_DUMPING_FW_LOG, 929 }; 930 931 static inline bool iwl_mvm_is_radio_killed(struct iwl_mvm *mvm) 932 { 933 return test_bit(IWL_MVM_STATUS_HW_RFKILL, &mvm->status) || 934 test_bit(IWL_MVM_STATUS_HW_CTKILL, &mvm->status); 935 } 936 937 static inline bool iwl_mvm_is_radio_hw_killed(struct iwl_mvm *mvm) 938 { 939 return test_bit(IWL_MVM_STATUS_HW_RFKILL, &mvm->status); 940 } 941 942 /* Must be called with rcu_read_lock() held and it can only be 943 * released when mvmsta is not needed anymore. 944 */ 945 static inline struct iwl_mvm_sta * 946 iwl_mvm_sta_from_staid_rcu(struct iwl_mvm *mvm, u8 sta_id) 947 { 948 struct ieee80211_sta *sta; 949 950 if (sta_id >= ARRAY_SIZE(mvm->fw_id_to_mac_id)) 951 return NULL; 952 953 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]); 954 955 /* This can happen if the station has been removed right now */ 956 if (IS_ERR_OR_NULL(sta)) 957 return NULL; 958 959 return iwl_mvm_sta_from_mac80211(sta); 960 } 961 962 static inline struct iwl_mvm_sta * 963 iwl_mvm_sta_from_staid_protected(struct iwl_mvm *mvm, u8 sta_id) 964 { 965 struct ieee80211_sta *sta; 966 967 if (sta_id >= ARRAY_SIZE(mvm->fw_id_to_mac_id)) 968 return NULL; 969 970 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id], 971 lockdep_is_held(&mvm->mutex)); 972 973 /* This can happen if the station has been removed right now */ 974 if (IS_ERR_OR_NULL(sta)) 975 return NULL; 976 977 return iwl_mvm_sta_from_mac80211(sta); 978 } 979 980 static inline bool iwl_mvm_is_d0i3_supported(struct iwl_mvm *mvm) 981 { 982 return !iwlwifi_mod_params.d0i3_disable && 983 fw_has_capa(&mvm->fw->ucode_capa, 984 IWL_UCODE_TLV_CAPA_D0I3_SUPPORT); 985 } 986 987 static inline bool iwl_mvm_is_dqa_supported(struct iwl_mvm *mvm) 988 { 989 /* Make sure DQA isn't allowed in driver until feature is complete */ 990 return false && fw_has_capa(&mvm->fw->ucode_capa, 991 IWL_UCODE_TLV_CAPA_DQA_SUPPORT); 992 } 993 994 static inline bool iwl_mvm_enter_d0i3_on_suspend(struct iwl_mvm *mvm) 995 { 996 /* For now we only use this mode to differentiate between 997 * slave transports, which handle D0i3 entry in suspend by 998 * themselves in conjunction with runtime PM D0i3. So, this 999 * function is used to check whether we need to do anything 1000 * when entering suspend or if the transport layer has already 1001 * done it. 1002 */ 1003 return (mvm->trans->system_pm_mode == IWL_PLAT_PM_MODE_D0I3) && 1004 (mvm->trans->runtime_pm_mode != IWL_PLAT_PM_MODE_D0I3); 1005 } 1006 1007 static inline bool iwl_mvm_is_lar_supported(struct iwl_mvm *mvm) 1008 { 1009 bool nvm_lar = mvm->nvm_data->lar_enabled; 1010 bool tlv_lar = fw_has_capa(&mvm->fw->ucode_capa, 1011 IWL_UCODE_TLV_CAPA_LAR_SUPPORT); 1012 1013 if (iwlwifi_mod_params.lar_disable) 1014 return false; 1015 1016 /* 1017 * Enable LAR only if it is supported by the FW (TLV) && 1018 * enabled in the NVM 1019 */ 1020 if (mvm->cfg->device_family == IWL_DEVICE_FAMILY_8000) 1021 return nvm_lar && tlv_lar; 1022 else 1023 return tlv_lar; 1024 } 1025 1026 static inline bool iwl_mvm_is_wifi_mcc_supported(struct iwl_mvm *mvm) 1027 { 1028 return fw_has_api(&mvm->fw->ucode_capa, 1029 IWL_UCODE_TLV_API_WIFI_MCC_UPDATE) || 1030 fw_has_capa(&mvm->fw->ucode_capa, 1031 IWL_UCODE_TLV_CAPA_LAR_MULTI_MCC); 1032 } 1033 1034 static inline bool iwl_mvm_bt_is_plcr_supported(struct iwl_mvm *mvm) 1035 { 1036 return fw_has_capa(&mvm->fw->ucode_capa, 1037 IWL_UCODE_TLV_CAPA_BT_COEX_PLCR) && 1038 IWL_MVM_BT_COEX_CORUNNING; 1039 } 1040 1041 static inline bool iwl_mvm_bt_is_rrc_supported(struct iwl_mvm *mvm) 1042 { 1043 return fw_has_capa(&mvm->fw->ucode_capa, 1044 IWL_UCODE_TLV_CAPA_BT_COEX_RRC) && 1045 IWL_MVM_BT_COEX_RRC; 1046 } 1047 1048 static inline bool iwl_mvm_is_csum_supported(struct iwl_mvm *mvm) 1049 { 1050 return fw_has_capa(&mvm->fw->ucode_capa, 1051 IWL_UCODE_TLV_CAPA_CSUM_SUPPORT); 1052 } 1053 1054 static inline bool iwl_mvm_is_mplut_supported(struct iwl_mvm *mvm) 1055 { 1056 return fw_has_capa(&mvm->fw->ucode_capa, 1057 IWL_UCODE_TLV_CAPA_BT_MPLUT_SUPPORT) && 1058 IWL_MVM_BT_COEX_MPLUT; 1059 } 1060 1061 static inline 1062 bool iwl_mvm_is_p2p_standalone_uapsd_supported(struct iwl_mvm *mvm) 1063 { 1064 return fw_has_capa(&mvm->fw->ucode_capa, 1065 IWL_UCODE_TLV_CAPA_P2P_STANDALONE_UAPSD) && 1066 IWL_MVM_P2P_UAPSD_STANDALONE; 1067 } 1068 1069 static inline bool iwl_mvm_has_new_rx_api(struct iwl_mvm *mvm) 1070 { 1071 return fw_has_capa(&mvm->fw->ucode_capa, 1072 IWL_UCODE_TLV_CAPA_MULTI_QUEUE_RX_SUPPORT); 1073 } 1074 1075 static inline bool iwl_mvm_is_tt_in_fw(struct iwl_mvm *mvm) 1076 { 1077 #ifdef CONFIG_THERMAL 1078 /* these two TLV are redundant since the responsibility to CT-kill by 1079 * FW happens only after we send at least one command of 1080 * temperature THs report. 1081 */ 1082 return fw_has_capa(&mvm->fw->ucode_capa, 1083 IWL_UCODE_TLV_CAPA_CT_KILL_BY_FW) && 1084 fw_has_capa(&mvm->fw->ucode_capa, 1085 IWL_UCODE_TLV_CAPA_TEMP_THS_REPORT_SUPPORT); 1086 #else /* CONFIG_THERMAL */ 1087 return false; 1088 #endif /* CONFIG_THERMAL */ 1089 } 1090 1091 static inline bool iwl_mvm_is_ctdp_supported(struct iwl_mvm *mvm) 1092 { 1093 return fw_has_capa(&mvm->fw->ucode_capa, 1094 IWL_UCODE_TLV_CAPA_CTDP_SUPPORT); 1095 } 1096 1097 extern const u8 iwl_mvm_ac_to_tx_fifo[]; 1098 1099 struct iwl_rate_info { 1100 u8 plcp; /* uCode API: IWL_RATE_6M_PLCP, etc. */ 1101 u8 plcp_siso; /* uCode API: IWL_RATE_SISO_6M_PLCP, etc. */ 1102 u8 plcp_mimo2; /* uCode API: IWL_RATE_MIMO2_6M_PLCP, etc. */ 1103 u8 plcp_mimo3; /* uCode API: IWL_RATE_MIMO3_6M_PLCP, etc. */ 1104 u8 ieee; /* MAC header: IWL_RATE_6M_IEEE, etc. */ 1105 }; 1106 1107 void __iwl_mvm_mac_stop(struct iwl_mvm *mvm); 1108 int __iwl_mvm_mac_start(struct iwl_mvm *mvm); 1109 1110 /****************** 1111 * MVM Methods 1112 ******************/ 1113 /* uCode */ 1114 int iwl_run_init_mvm_ucode(struct iwl_mvm *mvm, bool read_nvm); 1115 1116 /* Utils */ 1117 int iwl_mvm_legacy_rate_to_mac80211_idx(u32 rate_n_flags, 1118 enum ieee80211_band band); 1119 void iwl_mvm_hwrate_to_tx_rate(u32 rate_n_flags, 1120 enum ieee80211_band band, 1121 struct ieee80211_tx_rate *r); 1122 u8 iwl_mvm_mac80211_idx_to_hwrate(int rate_idx); 1123 void iwl_mvm_dump_nic_error_log(struct iwl_mvm *mvm); 1124 u8 first_antenna(u8 mask); 1125 u8 iwl_mvm_next_antenna(struct iwl_mvm *mvm, u8 valid, u8 last_idx); 1126 1127 /* Tx / Host Commands */ 1128 int __must_check iwl_mvm_send_cmd(struct iwl_mvm *mvm, 1129 struct iwl_host_cmd *cmd); 1130 int __must_check iwl_mvm_send_cmd_pdu(struct iwl_mvm *mvm, u32 id, 1131 u32 flags, u16 len, const void *data); 1132 int __must_check iwl_mvm_send_cmd_status(struct iwl_mvm *mvm, 1133 struct iwl_host_cmd *cmd, 1134 u32 *status); 1135 int __must_check iwl_mvm_send_cmd_pdu_status(struct iwl_mvm *mvm, u32 id, 1136 u16 len, const void *data, 1137 u32 *status); 1138 int iwl_mvm_tx_skb(struct iwl_mvm *mvm, struct sk_buff *skb, 1139 struct ieee80211_sta *sta); 1140 int iwl_mvm_tx_skb_non_sta(struct iwl_mvm *mvm, struct sk_buff *skb); 1141 void iwl_mvm_set_tx_cmd(struct iwl_mvm *mvm, struct sk_buff *skb, 1142 struct iwl_tx_cmd *tx_cmd, 1143 struct ieee80211_tx_info *info, u8 sta_id); 1144 void iwl_mvm_set_tx_cmd_rate(struct iwl_mvm *mvm, struct iwl_tx_cmd *tx_cmd, 1145 struct ieee80211_tx_info *info, 1146 struct ieee80211_sta *sta, __le16 fc); 1147 #ifdef CONFIG_IWLWIFI_DEBUG 1148 const char *iwl_mvm_get_tx_fail_reason(u32 status); 1149 #else 1150 static inline const char *iwl_mvm_get_tx_fail_reason(u32 status) { return ""; } 1151 #endif 1152 int iwl_mvm_flush_tx_path(struct iwl_mvm *mvm, u32 tfd_msk, u32 flags); 1153 void iwl_mvm_async_handlers_purge(struct iwl_mvm *mvm); 1154 1155 static inline void iwl_mvm_set_tx_cmd_ccmp(struct ieee80211_tx_info *info, 1156 struct iwl_tx_cmd *tx_cmd) 1157 { 1158 struct ieee80211_key_conf *keyconf = info->control.hw_key; 1159 1160 tx_cmd->sec_ctl = TX_CMD_SEC_CCM; 1161 memcpy(tx_cmd->key, keyconf->key, keyconf->keylen); 1162 if (info->flags & IEEE80211_TX_CTL_AMPDU) 1163 tx_cmd->tx_flags |= cpu_to_le32(TX_CMD_FLG_CCMP_AGG); 1164 } 1165 1166 static inline void iwl_mvm_wait_for_async_handlers(struct iwl_mvm *mvm) 1167 { 1168 flush_work(&mvm->async_handlers_wk); 1169 } 1170 1171 /* Statistics */ 1172 void iwl_mvm_handle_rx_statistics(struct iwl_mvm *mvm, 1173 struct iwl_rx_packet *pkt); 1174 void iwl_mvm_rx_statistics(struct iwl_mvm *mvm, 1175 struct iwl_rx_cmd_buffer *rxb); 1176 int iwl_mvm_request_statistics(struct iwl_mvm *mvm, bool clear); 1177 void iwl_mvm_accu_radio_stats(struct iwl_mvm *mvm); 1178 1179 /* NVM */ 1180 int iwl_nvm_init(struct iwl_mvm *mvm, bool read_nvm_from_nic); 1181 int iwl_mvm_load_nvm_to_nic(struct iwl_mvm *mvm); 1182 1183 static inline u8 iwl_mvm_get_valid_tx_ant(struct iwl_mvm *mvm) 1184 { 1185 return mvm->nvm_data && mvm->nvm_data->valid_tx_ant ? 1186 mvm->fw->valid_tx_ant & mvm->nvm_data->valid_tx_ant : 1187 mvm->fw->valid_tx_ant; 1188 } 1189 1190 static inline u8 iwl_mvm_get_valid_rx_ant(struct iwl_mvm *mvm) 1191 { 1192 return mvm->nvm_data && mvm->nvm_data->valid_rx_ant ? 1193 mvm->fw->valid_rx_ant & mvm->nvm_data->valid_rx_ant : 1194 mvm->fw->valid_rx_ant; 1195 } 1196 1197 static inline u32 iwl_mvm_get_phy_config(struct iwl_mvm *mvm) 1198 { 1199 u32 phy_config = ~(FW_PHY_CFG_TX_CHAIN | 1200 FW_PHY_CFG_RX_CHAIN); 1201 u32 valid_rx_ant = iwl_mvm_get_valid_rx_ant(mvm); 1202 u32 valid_tx_ant = iwl_mvm_get_valid_tx_ant(mvm); 1203 1204 phy_config |= valid_tx_ant << FW_PHY_CFG_TX_CHAIN_POS | 1205 valid_rx_ant << FW_PHY_CFG_RX_CHAIN_POS; 1206 1207 return mvm->fw->phy_config & phy_config; 1208 } 1209 1210 int iwl_mvm_up(struct iwl_mvm *mvm); 1211 int iwl_mvm_load_d3_fw(struct iwl_mvm *mvm); 1212 1213 int iwl_mvm_mac_setup_register(struct iwl_mvm *mvm); 1214 bool iwl_mvm_bcast_filter_build_cmd(struct iwl_mvm *mvm, 1215 struct iwl_bcast_filter_cmd *cmd); 1216 1217 /* 1218 * FW notifications / CMD responses handlers 1219 * Convention: iwl_mvm_rx_<NAME OF THE CMD> 1220 */ 1221 void iwl_mvm_rx_rx_phy_cmd(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb); 1222 void iwl_mvm_rx_rx_mpdu(struct iwl_mvm *mvm, struct napi_struct *napi, 1223 struct iwl_rx_cmd_buffer *rxb); 1224 void iwl_mvm_rx_phy_cmd_mq(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb); 1225 void iwl_mvm_rx_mpdu_mq(struct iwl_mvm *mvm, struct napi_struct *napi, 1226 struct iwl_rx_cmd_buffer *rxb, int queue); 1227 void iwl_mvm_rx_frame_release(struct iwl_mvm *mvm, 1228 struct iwl_rx_cmd_buffer *rxb, int queue); 1229 int iwl_mvm_notify_rx_queue(struct iwl_mvm *mvm, u32 rxq_mask, 1230 const u8 *data, u32 count); 1231 void iwl_mvm_rx_queue_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb, 1232 int queue); 1233 void iwl_mvm_rx_tx_cmd(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb); 1234 void iwl_mvm_rx_ba_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb); 1235 void iwl_mvm_rx_ant_coupling_notif(struct iwl_mvm *mvm, 1236 struct iwl_rx_cmd_buffer *rxb); 1237 void iwl_mvm_rx_fw_error(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb); 1238 void iwl_mvm_rx_card_state_notif(struct iwl_mvm *mvm, 1239 struct iwl_rx_cmd_buffer *rxb); 1240 void iwl_mvm_rx_mfuart_notif(struct iwl_mvm *mvm, 1241 struct iwl_rx_cmd_buffer *rxb); 1242 void iwl_mvm_rx_shared_mem_cfg_notif(struct iwl_mvm *mvm, 1243 struct iwl_rx_cmd_buffer *rxb); 1244 1245 /* MVM PHY */ 1246 int iwl_mvm_phy_ctxt_add(struct iwl_mvm *mvm, struct iwl_mvm_phy_ctxt *ctxt, 1247 struct cfg80211_chan_def *chandef, 1248 u8 chains_static, u8 chains_dynamic); 1249 int iwl_mvm_phy_ctxt_changed(struct iwl_mvm *mvm, struct iwl_mvm_phy_ctxt *ctxt, 1250 struct cfg80211_chan_def *chandef, 1251 u8 chains_static, u8 chains_dynamic); 1252 void iwl_mvm_phy_ctxt_ref(struct iwl_mvm *mvm, 1253 struct iwl_mvm_phy_ctxt *ctxt); 1254 void iwl_mvm_phy_ctxt_unref(struct iwl_mvm *mvm, 1255 struct iwl_mvm_phy_ctxt *ctxt); 1256 int iwl_mvm_phy_ctx_count(struct iwl_mvm *mvm); 1257 u8 iwl_mvm_get_channel_width(struct cfg80211_chan_def *chandef); 1258 u8 iwl_mvm_get_ctrl_pos(struct cfg80211_chan_def *chandef); 1259 1260 /* MAC (virtual interface) programming */ 1261 int iwl_mvm_mac_ctxt_init(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1262 void iwl_mvm_mac_ctxt_release(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1263 int iwl_mvm_mac_ctxt_add(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1264 int iwl_mvm_mac_ctxt_changed(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1265 bool force_assoc_off, const u8 *bssid_override); 1266 int iwl_mvm_mac_ctxt_remove(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1267 u32 iwl_mvm_mac_get_queues_mask(struct ieee80211_vif *vif); 1268 int iwl_mvm_mac_ctxt_beacon_changed(struct iwl_mvm *mvm, 1269 struct ieee80211_vif *vif); 1270 void iwl_mvm_rx_beacon_notif(struct iwl_mvm *mvm, 1271 struct iwl_rx_cmd_buffer *rxb); 1272 void iwl_mvm_rx_missed_beacons_notif(struct iwl_mvm *mvm, 1273 struct iwl_rx_cmd_buffer *rxb); 1274 void iwl_mvm_rx_stored_beacon_notif(struct iwl_mvm *mvm, 1275 struct iwl_rx_cmd_buffer *rxb); 1276 void iwl_mvm_mu_mimo_grp_notif(struct iwl_mvm *mvm, 1277 struct iwl_rx_cmd_buffer *rxb); 1278 void iwl_mvm_window_status_notif(struct iwl_mvm *mvm, 1279 struct iwl_rx_cmd_buffer *rxb); 1280 void iwl_mvm_mac_ctxt_recalc_tsf_id(struct iwl_mvm *mvm, 1281 struct ieee80211_vif *vif); 1282 unsigned long iwl_mvm_get_used_hw_queues(struct iwl_mvm *mvm, 1283 struct ieee80211_vif *exclude_vif); 1284 /* Bindings */ 1285 int iwl_mvm_binding_add_vif(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1286 int iwl_mvm_binding_remove_vif(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1287 1288 /* Quota management */ 1289 int iwl_mvm_update_quotas(struct iwl_mvm *mvm, bool force_upload, 1290 struct ieee80211_vif *disabled_vif); 1291 1292 /* Scanning */ 1293 int iwl_mvm_reg_scan_start(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1294 struct cfg80211_scan_request *req, 1295 struct ieee80211_scan_ies *ies); 1296 int iwl_mvm_scan_size(struct iwl_mvm *mvm); 1297 int iwl_mvm_scan_stop(struct iwl_mvm *mvm, int type, bool notify); 1298 int iwl_mvm_max_scan_ie_len(struct iwl_mvm *mvm); 1299 void iwl_mvm_report_scan_aborted(struct iwl_mvm *mvm); 1300 1301 /* Scheduled scan */ 1302 void iwl_mvm_rx_lmac_scan_complete_notif(struct iwl_mvm *mvm, 1303 struct iwl_rx_cmd_buffer *rxb); 1304 void iwl_mvm_rx_lmac_scan_iter_complete_notif(struct iwl_mvm *mvm, 1305 struct iwl_rx_cmd_buffer *rxb); 1306 int iwl_mvm_sched_scan_start(struct iwl_mvm *mvm, 1307 struct ieee80211_vif *vif, 1308 struct cfg80211_sched_scan_request *req, 1309 struct ieee80211_scan_ies *ies, 1310 int type); 1311 void iwl_mvm_rx_scan_match_found(struct iwl_mvm *mvm, 1312 struct iwl_rx_cmd_buffer *rxb); 1313 1314 /* UMAC scan */ 1315 int iwl_mvm_config_scan(struct iwl_mvm *mvm); 1316 void iwl_mvm_rx_umac_scan_complete_notif(struct iwl_mvm *mvm, 1317 struct iwl_rx_cmd_buffer *rxb); 1318 void iwl_mvm_rx_umac_scan_iter_complete_notif(struct iwl_mvm *mvm, 1319 struct iwl_rx_cmd_buffer *rxb); 1320 1321 /* Paging */ 1322 void iwl_free_fw_paging(struct iwl_mvm *mvm); 1323 1324 /* MVM debugfs */ 1325 #ifdef CONFIG_IWLWIFI_DEBUGFS 1326 int iwl_mvm_dbgfs_register(struct iwl_mvm *mvm, struct dentry *dbgfs_dir); 1327 void iwl_mvm_vif_dbgfs_register(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1328 void iwl_mvm_vif_dbgfs_clean(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1329 #else 1330 static inline int iwl_mvm_dbgfs_register(struct iwl_mvm *mvm, 1331 struct dentry *dbgfs_dir) 1332 { 1333 return 0; 1334 } 1335 static inline void 1336 iwl_mvm_vif_dbgfs_register(struct iwl_mvm *mvm, struct ieee80211_vif *vif) 1337 { 1338 } 1339 static inline void 1340 iwl_mvm_vif_dbgfs_clean(struct iwl_mvm *mvm, struct ieee80211_vif *vif) 1341 { 1342 } 1343 #endif /* CONFIG_IWLWIFI_DEBUGFS */ 1344 1345 /* rate scaling */ 1346 int iwl_mvm_send_lq_cmd(struct iwl_mvm *mvm, struct iwl_lq_cmd *lq, bool init); 1347 void iwl_mvm_update_frame_stats(struct iwl_mvm *mvm, u32 rate, bool agg); 1348 int rs_pretty_print_rate(char *buf, const u32 rate); 1349 void rs_update_last_rssi(struct iwl_mvm *mvm, 1350 struct iwl_lq_sta *lq_sta, 1351 struct ieee80211_rx_status *rx_status); 1352 1353 /* power management */ 1354 int iwl_mvm_power_update_device(struct iwl_mvm *mvm); 1355 int iwl_mvm_power_update_mac(struct iwl_mvm *mvm); 1356 int iwl_mvm_power_update_ps(struct iwl_mvm *mvm); 1357 int iwl_mvm_power_mac_dbgfs_read(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1358 char *buf, int bufsz); 1359 1360 void iwl_mvm_power_vif_assoc(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1361 void iwl_mvm_power_uapsd_misbehaving_ap_notif(struct iwl_mvm *mvm, 1362 struct iwl_rx_cmd_buffer *rxb); 1363 1364 #ifdef CONFIG_IWLWIFI_LEDS 1365 int iwl_mvm_leds_init(struct iwl_mvm *mvm); 1366 void iwl_mvm_leds_exit(struct iwl_mvm *mvm); 1367 #else 1368 static inline int iwl_mvm_leds_init(struct iwl_mvm *mvm) 1369 { 1370 return 0; 1371 } 1372 static inline void iwl_mvm_leds_exit(struct iwl_mvm *mvm) 1373 { 1374 } 1375 #endif 1376 1377 /* D3 (WoWLAN, NetDetect) */ 1378 int iwl_mvm_suspend(struct ieee80211_hw *hw, struct cfg80211_wowlan *wowlan); 1379 int iwl_mvm_resume(struct ieee80211_hw *hw); 1380 void iwl_mvm_set_wakeup(struct ieee80211_hw *hw, bool enabled); 1381 void iwl_mvm_set_rekey_data(struct ieee80211_hw *hw, 1382 struct ieee80211_vif *vif, 1383 struct cfg80211_gtk_rekey_data *data); 1384 void iwl_mvm_ipv6_addr_change(struct ieee80211_hw *hw, 1385 struct ieee80211_vif *vif, 1386 struct inet6_dev *idev); 1387 void iwl_mvm_set_default_unicast_key(struct ieee80211_hw *hw, 1388 struct ieee80211_vif *vif, int idx); 1389 extern const struct file_operations iwl_dbgfs_d3_test_ops; 1390 #ifdef CONFIG_PM 1391 int iwl_mvm_wowlan_config_key_params(struct iwl_mvm *mvm, 1392 struct ieee80211_vif *vif, 1393 bool host_awake, 1394 u32 cmd_flags); 1395 void iwl_mvm_d0i3_update_keys(struct iwl_mvm *mvm, 1396 struct ieee80211_vif *vif, 1397 struct iwl_wowlan_status *status); 1398 void iwl_mvm_set_last_nonqos_seq(struct iwl_mvm *mvm, 1399 struct ieee80211_vif *vif); 1400 #else 1401 static inline int iwl_mvm_wowlan_config_key_params(struct iwl_mvm *mvm, 1402 struct ieee80211_vif *vif, 1403 bool host_awake, 1404 u32 cmd_flags) 1405 { 1406 return 0; 1407 } 1408 1409 static inline void iwl_mvm_d0i3_update_keys(struct iwl_mvm *mvm, 1410 struct ieee80211_vif *vif, 1411 struct iwl_wowlan_status *status) 1412 { 1413 } 1414 1415 static inline void 1416 iwl_mvm_set_last_nonqos_seq(struct iwl_mvm *mvm, struct ieee80211_vif *vif) 1417 { 1418 } 1419 #endif 1420 void iwl_mvm_set_wowlan_qos_seq(struct iwl_mvm_sta *mvm_ap_sta, 1421 struct iwl_wowlan_config_cmd *cmd); 1422 int iwl_mvm_send_proto_offload(struct iwl_mvm *mvm, 1423 struct ieee80211_vif *vif, 1424 bool disable_offloading, 1425 bool offload_ns, 1426 u32 cmd_flags); 1427 1428 /* D0i3 */ 1429 void iwl_mvm_ref(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type); 1430 void iwl_mvm_unref(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type); 1431 int iwl_mvm_ref_sync(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type); 1432 bool iwl_mvm_ref_taken(struct iwl_mvm *mvm); 1433 void iwl_mvm_d0i3_enable_tx(struct iwl_mvm *mvm, __le16 *qos_seq); 1434 int iwl_mvm_enter_d0i3(struct iwl_op_mode *op_mode); 1435 int iwl_mvm_exit_d0i3(struct iwl_op_mode *op_mode); 1436 int _iwl_mvm_exit_d0i3(struct iwl_mvm *mvm); 1437 1438 /* BT Coex */ 1439 int iwl_send_bt_init_conf(struct iwl_mvm *mvm); 1440 void iwl_mvm_rx_bt_coex_notif(struct iwl_mvm *mvm, 1441 struct iwl_rx_cmd_buffer *rxb); 1442 void iwl_mvm_bt_rssi_event(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1443 enum ieee80211_rssi_event_data); 1444 void iwl_mvm_bt_coex_vif_change(struct iwl_mvm *mvm); 1445 u16 iwl_mvm_coex_agg_time_limit(struct iwl_mvm *mvm, 1446 struct ieee80211_sta *sta); 1447 bool iwl_mvm_bt_coex_is_mimo_allowed(struct iwl_mvm *mvm, 1448 struct ieee80211_sta *sta); 1449 bool iwl_mvm_bt_coex_is_ant_avail(struct iwl_mvm *mvm, u8 ant); 1450 bool iwl_mvm_bt_coex_is_shared_ant_avail(struct iwl_mvm *mvm); 1451 bool iwl_mvm_bt_coex_is_tpc_allowed(struct iwl_mvm *mvm, 1452 enum ieee80211_band band); 1453 u8 iwl_mvm_bt_coex_tx_prio(struct iwl_mvm *mvm, struct ieee80211_hdr *hdr, 1454 struct ieee80211_tx_info *info, u8 ac); 1455 1456 bool iwl_mvm_bt_coex_is_shared_ant_avail_old(struct iwl_mvm *mvm); 1457 void iwl_mvm_bt_coex_vif_change_old(struct iwl_mvm *mvm); 1458 int iwl_send_bt_init_conf_old(struct iwl_mvm *mvm); 1459 void iwl_mvm_rx_bt_coex_notif_old(struct iwl_mvm *mvm, 1460 struct iwl_rx_cmd_buffer *rxb); 1461 void iwl_mvm_bt_rssi_event_old(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1462 enum ieee80211_rssi_event_data); 1463 u16 iwl_mvm_coex_agg_time_limit_old(struct iwl_mvm *mvm, 1464 struct ieee80211_sta *sta); 1465 bool iwl_mvm_bt_coex_is_mimo_allowed_old(struct iwl_mvm *mvm, 1466 struct ieee80211_sta *sta); 1467 bool iwl_mvm_bt_coex_is_tpc_allowed_old(struct iwl_mvm *mvm, 1468 enum ieee80211_band band); 1469 void iwl_mvm_rx_ant_coupling_notif_old(struct iwl_mvm *mvm, 1470 struct iwl_rx_cmd_buffer *rxb); 1471 1472 /* beacon filtering */ 1473 #ifdef CONFIG_IWLWIFI_DEBUGFS 1474 void 1475 iwl_mvm_beacon_filter_debugfs_parameters(struct ieee80211_vif *vif, 1476 struct iwl_beacon_filter_cmd *cmd); 1477 #else 1478 static inline void 1479 iwl_mvm_beacon_filter_debugfs_parameters(struct ieee80211_vif *vif, 1480 struct iwl_beacon_filter_cmd *cmd) 1481 {} 1482 #endif 1483 int iwl_mvm_update_d0i3_power_mode(struct iwl_mvm *mvm, 1484 struct ieee80211_vif *vif, 1485 bool enable, u32 flags); 1486 int iwl_mvm_enable_beacon_filter(struct iwl_mvm *mvm, 1487 struct ieee80211_vif *vif, 1488 u32 flags); 1489 int iwl_mvm_disable_beacon_filter(struct iwl_mvm *mvm, 1490 struct ieee80211_vif *vif, 1491 u32 flags); 1492 /* SMPS */ 1493 void iwl_mvm_update_smps(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1494 enum iwl_mvm_smps_type_request req_type, 1495 enum ieee80211_smps_mode smps_request); 1496 bool iwl_mvm_rx_diversity_allowed(struct iwl_mvm *mvm); 1497 1498 /* Low latency */ 1499 int iwl_mvm_update_low_latency(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1500 bool value); 1501 /* get SystemLowLatencyMode - only needed for beacon threshold? */ 1502 bool iwl_mvm_low_latency(struct iwl_mvm *mvm); 1503 /* get VMACLowLatencyMode */ 1504 static inline bool iwl_mvm_vif_low_latency(struct iwl_mvm_vif *mvmvif) 1505 { 1506 /* 1507 * should this consider associated/active/... state? 1508 * 1509 * Normally low-latency should only be active on interfaces 1510 * that are active, but at least with debugfs it can also be 1511 * enabled on interfaces that aren't active. However, when 1512 * interface aren't active then they aren't added into the 1513 * binding, so this has no real impact. For now, just return 1514 * the current desired low-latency state. 1515 */ 1516 return mvmvif->low_latency_dbgfs || 1517 mvmvif->low_latency_traffic || 1518 mvmvif->low_latency_vcmd; 1519 } 1520 1521 /* hw scheduler queue config */ 1522 void iwl_mvm_enable_txq(struct iwl_mvm *mvm, int queue, int mac80211_queue, 1523 u16 ssn, const struct iwl_trans_txq_scd_cfg *cfg, 1524 unsigned int wdg_timeout); 1525 /* 1526 * Disable a TXQ. 1527 * Note that in non-DQA mode the %mac80211_queue and %tid params are ignored. 1528 */ 1529 void iwl_mvm_disable_txq(struct iwl_mvm *mvm, int queue, int mac80211_queue, 1530 u8 tid, u8 flags); 1531 int iwl_mvm_find_free_queue(struct iwl_mvm *mvm, u8 minq, u8 maxq); 1532 1533 /* Return a bitmask with all the hw supported queues, except for the 1534 * command queue, which can't be flushed. 1535 */ 1536 static inline u32 iwl_mvm_flushable_queues(struct iwl_mvm *mvm) 1537 { 1538 return ((BIT(mvm->cfg->base_params->num_of_queues) - 1) & 1539 ~BIT(IWL_MVM_CMD_QUEUE)); 1540 } 1541 1542 static inline 1543 void iwl_mvm_enable_ac_txq(struct iwl_mvm *mvm, int queue, int mac80211_queue, 1544 u8 fifo, u16 ssn, unsigned int wdg_timeout) 1545 { 1546 struct iwl_trans_txq_scd_cfg cfg = { 1547 .fifo = fifo, 1548 .tid = IWL_MAX_TID_COUNT, 1549 .aggregate = false, 1550 .frame_limit = IWL_FRAME_LIMIT, 1551 }; 1552 1553 iwl_mvm_enable_txq(mvm, queue, mac80211_queue, ssn, &cfg, wdg_timeout); 1554 } 1555 1556 static inline void iwl_mvm_stop_device(struct iwl_mvm *mvm) 1557 { 1558 mvm->ucode_loaded = false; 1559 iwl_trans_stop_device(mvm->trans); 1560 } 1561 1562 /* Stop/start all mac queues in a given bitmap */ 1563 void iwl_mvm_start_mac_queues(struct iwl_mvm *mvm, unsigned long mq); 1564 void iwl_mvm_stop_mac_queues(struct iwl_mvm *mvm, unsigned long mq); 1565 1566 /* Thermal management and CT-kill */ 1567 void iwl_mvm_tt_tx_backoff(struct iwl_mvm *mvm, u32 backoff); 1568 void iwl_mvm_tt_temp_changed(struct iwl_mvm *mvm, u32 temp); 1569 void iwl_mvm_temp_notif(struct iwl_mvm *mvm, 1570 struct iwl_rx_cmd_buffer *rxb); 1571 void iwl_mvm_tt_handler(struct iwl_mvm *mvm); 1572 void iwl_mvm_thermal_initialize(struct iwl_mvm *mvm, u32 min_backoff); 1573 void iwl_mvm_thermal_exit(struct iwl_mvm *mvm); 1574 void iwl_mvm_set_hw_ctkill_state(struct iwl_mvm *mvm, bool state); 1575 int iwl_mvm_get_temp(struct iwl_mvm *mvm, s32 *temp); 1576 void iwl_mvm_ct_kill_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb); 1577 int iwl_mvm_send_temp_report_ths_cmd(struct iwl_mvm *mvm); 1578 int iwl_mvm_ctdp_command(struct iwl_mvm *mvm, u32 op, u32 budget); 1579 1580 /* Location Aware Regulatory */ 1581 struct iwl_mcc_update_resp * 1582 iwl_mvm_update_mcc(struct iwl_mvm *mvm, const char *alpha2, 1583 enum iwl_mcc_source src_id); 1584 int iwl_mvm_init_mcc(struct iwl_mvm *mvm); 1585 void iwl_mvm_rx_chub_update_mcc(struct iwl_mvm *mvm, 1586 struct iwl_rx_cmd_buffer *rxb); 1587 struct ieee80211_regdomain *iwl_mvm_get_regdomain(struct wiphy *wiphy, 1588 const char *alpha2, 1589 enum iwl_mcc_source src_id, 1590 bool *changed); 1591 struct ieee80211_regdomain *iwl_mvm_get_current_regdomain(struct iwl_mvm *mvm, 1592 bool *changed); 1593 int iwl_mvm_init_fw_regd(struct iwl_mvm *mvm); 1594 void iwl_mvm_update_changed_regdom(struct iwl_mvm *mvm); 1595 1596 /* smart fifo */ 1597 int iwl_mvm_sf_update(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1598 bool added_vif); 1599 1600 /* TDLS */ 1601 1602 /* 1603 * We use TID 4 (VI) as a FW-used-only TID when TDLS connections are present. 1604 * This TID is marked as used vs the AP and all connected TDLS peers. 1605 */ 1606 #define IWL_MVM_TDLS_FW_TID 4 1607 1608 int iwl_mvm_tdls_sta_count(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1609 void iwl_mvm_teardown_tdls_peers(struct iwl_mvm *mvm); 1610 void iwl_mvm_recalc_tdls_state(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1611 bool sta_added); 1612 void iwl_mvm_mac_mgd_protect_tdls_discover(struct ieee80211_hw *hw, 1613 struct ieee80211_vif *vif); 1614 int iwl_mvm_tdls_channel_switch(struct ieee80211_hw *hw, 1615 struct ieee80211_vif *vif, 1616 struct ieee80211_sta *sta, u8 oper_class, 1617 struct cfg80211_chan_def *chandef, 1618 struct sk_buff *tmpl_skb, u32 ch_sw_tm_ie); 1619 void iwl_mvm_tdls_recv_channel_switch(struct ieee80211_hw *hw, 1620 struct ieee80211_vif *vif, 1621 struct ieee80211_tdls_ch_sw_params *params); 1622 void iwl_mvm_tdls_cancel_channel_switch(struct ieee80211_hw *hw, 1623 struct ieee80211_vif *vif, 1624 struct ieee80211_sta *sta); 1625 void iwl_mvm_rx_tdls_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb); 1626 void iwl_mvm_tdls_ch_switch_work(struct work_struct *work); 1627 1628 struct ieee80211_vif *iwl_mvm_get_bss_vif(struct iwl_mvm *mvm); 1629 1630 void iwl_mvm_nic_restart(struct iwl_mvm *mvm, bool fw_error); 1631 unsigned int iwl_mvm_get_wd_timeout(struct iwl_mvm *mvm, 1632 struct ieee80211_vif *vif, 1633 bool tdls, bool cmd_q); 1634 void iwl_mvm_connection_loss(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1635 const char *errmsg); 1636 1637 #endif /* __IWL_MVM_H__ */ 1638