1 /* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */ 2 /* 3 * Copyright (C) 2012-2014, 2018-2024 Intel Corporation 4 * Copyright (C) 2013-2015 Intel Mobile Communications GmbH 5 * Copyright (C) 2016-2017 Intel Deutschland GmbH 6 */ 7 #ifndef __IWL_MVM_H__ 8 #define __IWL_MVM_H__ 9 10 #include <linux/list.h> 11 #include <linux/spinlock.h> 12 #include <linux/cleanup.h> 13 #include <linux/leds.h> 14 #include <linux/in6.h> 15 16 #ifdef CONFIG_THERMAL 17 #include <linux/thermal.h> 18 #endif 19 20 #include <linux/ptp_clock_kernel.h> 21 22 #include <linux/ktime.h> 23 24 #include "iwl-op-mode.h" 25 #include "iwl-trans.h" 26 #include "fw/notif-wait.h" 27 #include "iwl-nvm-utils.h" 28 #include "fw/file.h" 29 #include "iwl-config.h" 30 #include "sta.h" 31 #include "fw-api.h" 32 #include "constants.h" 33 #include "fw/runtime.h" 34 #include "fw/dbg.h" 35 #include "fw/acpi.h" 36 #include "mei/iwl-mei.h" 37 #include "iwl-nvm-parse.h" 38 39 #include <linux/average.h> 40 41 #define IWL_MVM_MAX_ADDRESSES 5 42 /* RSSI offset for WkP */ 43 #define IWL_RSSI_OFFSET 50 44 #define IWL_MVM_MISSED_BEACONS_SINCE_RX_THOLD 4 45 #define IWL_MVM_MISSED_BEACONS_THRESHOLD 8 46 #define IWL_MVM_MISSED_BEACONS_THRESHOLD_LONG 19 47 48 /* A TimeUnit is 1024 microsecond */ 49 #define MSEC_TO_TU(_msec) (_msec*1000/1024) 50 51 /* For GO, this value represents the number of TUs before CSA "beacon 52 * 0" TBTT when the CSA time-event needs to be scheduled to start. It 53 * must be big enough to ensure that we switch in time. 54 */ 55 #define IWL_MVM_CHANNEL_SWITCH_TIME_GO 40 56 57 /* For client, this value represents the number of TUs before CSA 58 * "beacon 1" TBTT, instead. This is because we don't know when the 59 * GO/AP will be in the new channel, so we switch early enough. 60 */ 61 #define IWL_MVM_CHANNEL_SWITCH_TIME_CLIENT 10 62 63 /* 64 * This value (in TUs) is used to fine tune the CSA NoA end time which should 65 * be just before "beacon 0" TBTT. 66 */ 67 #define IWL_MVM_CHANNEL_SWITCH_MARGIN 4 68 69 /* 70 * Number of beacons to transmit on a new channel until we unblock tx to 71 * the stations, even if we didn't identify them on a new channel 72 */ 73 #define IWL_MVM_CS_UNBLOCK_TX_TIMEOUT 3 74 75 /* offchannel queue towards mac80211 */ 76 #define IWL_MVM_OFFCHANNEL_QUEUE 0 77 78 /* invalid value for FW link id */ 79 #define IWL_MVM_FW_LINK_ID_INVALID 0xff 80 81 extern const struct ieee80211_ops iwl_mvm_hw_ops; 82 extern const struct ieee80211_ops iwl_mvm_mld_hw_ops; 83 84 /** 85 * struct iwl_mvm_mod_params - module parameters for iwlmvm 86 * @init_dbg: if true, then the NIC won't be stopped if the INIT fw asserted. 87 * We will register to mac80211 to have testmode working. The NIC must not 88 * be up'ed after the INIT fw asserted. This is useful to be able to use 89 * proprietary tools over testmode to debug the INIT fw. 90 * @power_scheme: one of enum iwl_power_scheme 91 */ 92 struct iwl_mvm_mod_params { 93 bool init_dbg; 94 int power_scheme; 95 }; 96 extern struct iwl_mvm_mod_params iwlmvm_mod_params; 97 98 struct iwl_mvm_phy_ctxt { 99 u16 id; 100 u16 color; 101 u32 ref; 102 103 enum nl80211_chan_width width; 104 105 struct ieee80211_channel *channel; 106 107 /* track for RLC config command */ 108 u32 center_freq1; 109 bool rlc_disabled; 110 u32 channel_load_by_us; 111 }; 112 113 struct iwl_mvm_time_event_data { 114 struct ieee80211_vif *vif; 115 struct list_head list; 116 unsigned long end_jiffies; 117 u32 duration; 118 bool running; 119 u32 uid; 120 121 /* 122 * The access to the 'id' field must be done when the 123 * mvm->time_event_lock is held, as it value is used to indicate 124 * if the te is in the time event list or not (when id == TE_MAX) 125 */ 126 u32 id; 127 s8 link_id; 128 }; 129 130 /* Power management */ 131 132 /** 133 * enum iwl_power_scheme 134 * @IWL_POWER_SCHEME_CAM: Continuously Active Mode 135 * @IWL_POWER_SCHEME_BPS: Balanced Power Save (default) 136 * @IWL_POWER_SCHEME_LP: Low Power 137 */ 138 enum iwl_power_scheme { 139 IWL_POWER_SCHEME_CAM = 1, 140 IWL_POWER_SCHEME_BPS, 141 IWL_POWER_SCHEME_LP 142 }; 143 144 #define IWL_UAPSD_MAX_SP IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL 145 146 #ifdef CONFIG_IWLWIFI_DEBUGFS 147 enum iwl_dbgfs_pm_mask { 148 MVM_DEBUGFS_PM_KEEP_ALIVE = BIT(0), 149 MVM_DEBUGFS_PM_SKIP_OVER_DTIM = BIT(1), 150 MVM_DEBUGFS_PM_SKIP_DTIM_PERIODS = BIT(2), 151 MVM_DEBUGFS_PM_RX_DATA_TIMEOUT = BIT(3), 152 MVM_DEBUGFS_PM_TX_DATA_TIMEOUT = BIT(4), 153 MVM_DEBUGFS_PM_LPRX_ENA = BIT(6), 154 MVM_DEBUGFS_PM_LPRX_RSSI_THRESHOLD = BIT(7), 155 MVM_DEBUGFS_PM_SNOOZE_ENABLE = BIT(8), 156 MVM_DEBUGFS_PM_UAPSD_MISBEHAVING = BIT(9), 157 MVM_DEBUGFS_PM_USE_PS_POLL = BIT(10), 158 }; 159 160 struct iwl_dbgfs_pm { 161 u16 keep_alive_seconds; 162 u32 rx_data_timeout; 163 u32 tx_data_timeout; 164 bool skip_over_dtim; 165 u8 skip_dtim_periods; 166 bool lprx_ena; 167 u32 lprx_rssi_threshold; 168 bool snooze_ena; 169 bool uapsd_misbehaving; 170 bool use_ps_poll; 171 int mask; 172 }; 173 174 /* beacon filtering */ 175 176 enum iwl_dbgfs_bf_mask { 177 MVM_DEBUGFS_BF_ENERGY_DELTA = BIT(0), 178 MVM_DEBUGFS_BF_ROAMING_ENERGY_DELTA = BIT(1), 179 MVM_DEBUGFS_BF_ROAMING_STATE = BIT(2), 180 MVM_DEBUGFS_BF_TEMP_THRESHOLD = BIT(3), 181 MVM_DEBUGFS_BF_TEMP_FAST_FILTER = BIT(4), 182 MVM_DEBUGFS_BF_TEMP_SLOW_FILTER = BIT(5), 183 MVM_DEBUGFS_BF_ENABLE_BEACON_FILTER = BIT(6), 184 MVM_DEBUGFS_BF_DEBUG_FLAG = BIT(7), 185 MVM_DEBUGFS_BF_ESCAPE_TIMER = BIT(8), 186 MVM_DEBUGFS_BA_ESCAPE_TIMER = BIT(9), 187 MVM_DEBUGFS_BA_ENABLE_BEACON_ABORT = BIT(10), 188 }; 189 190 struct iwl_dbgfs_bf { 191 u32 bf_energy_delta; 192 u32 bf_roaming_energy_delta; 193 u32 bf_roaming_state; 194 u32 bf_temp_threshold; 195 u32 bf_temp_fast_filter; 196 u32 bf_temp_slow_filter; 197 u32 bf_enable_beacon_filter; 198 u32 bf_debug_flag; 199 u32 bf_escape_timer; 200 u32 ba_escape_timer; 201 u32 ba_enable_beacon_abort; 202 int mask; 203 }; 204 #endif 205 206 enum iwl_mvm_smps_type_request { 207 IWL_MVM_SMPS_REQ_BT_COEX, 208 IWL_MVM_SMPS_REQ_TT, 209 IWL_MVM_SMPS_REQ_PROT, 210 IWL_MVM_SMPS_REQ_FW, 211 NUM_IWL_MVM_SMPS_REQ, 212 }; 213 214 enum iwl_bt_force_ant_mode { 215 BT_FORCE_ANT_DIS = 0, 216 BT_FORCE_ANT_AUTO, 217 BT_FORCE_ANT_BT, 218 BT_FORCE_ANT_WIFI, 219 220 BT_FORCE_ANT_MAX, 221 }; 222 223 /** 224 * enum iwl_mvm_low_latency_force - low latency force mode set by debugfs 225 * @LOW_LATENCY_FORCE_UNSET: unset force mode 226 * @LOW_LATENCY_FORCE_ON: for low latency on 227 * @LOW_LATENCY_FORCE_OFF: for low latency off 228 * @NUM_LOW_LATENCY_FORCE: max num of modes 229 */ 230 enum iwl_mvm_low_latency_force { 231 LOW_LATENCY_FORCE_UNSET, 232 LOW_LATENCY_FORCE_ON, 233 LOW_LATENCY_FORCE_OFF, 234 NUM_LOW_LATENCY_FORCE 235 }; 236 237 /** 238 * enum iwl_mvm_low_latency_cause - low latency set causes 239 * @LOW_LATENCY_TRAFFIC: indicates low latency traffic was detected 240 * @LOW_LATENCY_DEBUGFS: low latency mode set from debugfs 241 * @LOW_LATENCY_VCMD: low latency mode set from vendor command 242 * @LOW_LATENCY_VIF_TYPE: low latency mode set because of vif type (ap) 243 * @LOW_LATENCY_DEBUGFS_FORCE_ENABLE: indicate that force mode is enabled 244 * the actual set/unset is done with LOW_LATENCY_DEBUGFS_FORCE 245 * @LOW_LATENCY_DEBUGFS_FORCE: low latency force mode from debugfs 246 * set this with LOW_LATENCY_DEBUGFS_FORCE_ENABLE flag 247 * in low_latency. 248 */ 249 enum iwl_mvm_low_latency_cause { 250 LOW_LATENCY_TRAFFIC = BIT(0), 251 LOW_LATENCY_DEBUGFS = BIT(1), 252 LOW_LATENCY_VCMD = BIT(2), 253 LOW_LATENCY_VIF_TYPE = BIT(3), 254 LOW_LATENCY_DEBUGFS_FORCE_ENABLE = BIT(4), 255 LOW_LATENCY_DEBUGFS_FORCE = BIT(5), 256 }; 257 258 /** 259 * struct iwl_mvm_link_bf_data - beacon filtering related data 260 * @ave_beacon_signal: average beacon signal 261 * @last_cqm_event: rssi of the last cqm event 262 * @bt_coex_min_thold: minimum threshold for BT coex 263 * @bt_coex_max_thold: maximum threshold for BT coex 264 * @last_bt_coex_event: rssi of the last BT coex event 265 */ 266 struct iwl_mvm_link_bf_data { 267 int ave_beacon_signal; 268 int last_cqm_event; 269 int bt_coex_min_thold; 270 int bt_coex_max_thold; 271 int last_bt_coex_event; 272 }; 273 274 /** 275 * struct iwl_probe_resp_data - data for NoA/CSA updates 276 * @rcu_head: used for freeing the data on update 277 * @notif: notification data 278 * @noa_len: length of NoA attribute, calculated from the notification 279 */ 280 struct iwl_probe_resp_data { 281 struct rcu_head rcu_head; 282 struct iwl_probe_resp_data_notif notif; 283 int noa_len; 284 }; 285 286 /** 287 * struct iwl_mvm_vif_link_info - per link data in Virtual Interface 288 * @ap_sta_id: the sta_id of the AP - valid only if VIF type is STA 289 * @fw_link_id: the id of the link according to the FW API 290 * @bssid: BSSID for this (client) interface 291 * @bcast_sta: station used for broadcast packets. Used by the following 292 * vifs: P2P_DEVICE, GO and AP. 293 * @beacon_stats: beacon statistics, containing the # of received beacons, 294 * # of received beacons accumulated over FW restart, and the current 295 * average signal of beacons retrieved from the firmware 296 * @smps_requests: the SMPS requests of different parts of the driver, 297 * combined on update to yield the overall request to mac80211. 298 * @probe_resp_data: data from FW notification to store NOA and CSA related 299 * data to be inserted into probe response. 300 * @he_ru_2mhz_block: 26-tone RU OFDMA transmissions should be blocked 301 * @queue_params: QoS params for this MAC 302 * @mgmt_queue: queue number for unbufferable management frames 303 * @igtk: the current IGTK programmed into the firmware 304 * @active: indicates the link is active in FW (for sanity checking) 305 * @cab_queue: content-after-beacon (multicast) queue 306 * @listen_lmac: indicates this link is allocated to the listen LMAC 307 * @mcast_sta: multicast station 308 * @phy_ctxt: phy context allocated to this link, if any 309 * @bf_data: beacon filtering data 310 */ 311 struct iwl_mvm_vif_link_info { 312 u8 bssid[ETH_ALEN]; 313 u8 ap_sta_id; 314 u8 fw_link_id; 315 316 struct iwl_mvm_int_sta bcast_sta; 317 struct iwl_mvm_int_sta mcast_sta; 318 319 struct { 320 u32 num_beacons, accu_num_beacons; 321 u8 avg_signal; 322 } beacon_stats; 323 324 enum ieee80211_smps_mode smps_requests[NUM_IWL_MVM_SMPS_REQ]; 325 struct iwl_probe_resp_data __rcu *probe_resp_data; 326 327 struct ieee80211_key_conf *igtk; 328 329 bool he_ru_2mhz_block; 330 bool active; 331 bool listen_lmac; 332 333 u16 cab_queue; 334 /* Assigned while mac80211 has the link in a channel context, 335 * or, for P2P Device, while it exists. 336 */ 337 struct iwl_mvm_phy_ctxt *phy_ctxt; 338 /* QoS data from mac80211, need to store this here 339 * as mac80211 has a separate callback but we need 340 * to have the data for the MAC context 341 */ 342 struct ieee80211_tx_queue_params queue_params[IEEE80211_NUM_ACS]; 343 344 u16 mgmt_queue; 345 346 struct iwl_mvm_link_bf_data bf_data; 347 }; 348 349 /** 350 * enum iwl_mvm_esr_state - defines reasons for which the EMLSR is exited or 351 * blocked. 352 * The low 16 bits are used for blocking reasons, and the 16 higher bits 353 * are used for exit reasons. 354 * For the blocking reasons - use iwl_mvm_(un)block_esr(), and for the exit 355 * reasons - use iwl_mvm_exit_esr(). 356 * 357 * Note: new reasons shall be added to HANDLE_ESR_REASONS as well (for logs) 358 * 359 * @IWL_MVM_ESR_BLOCKED_PREVENTION: Prevent EMLSR to avoid entering and exiting 360 * in a loop. 361 * @IWL_MVM_ESR_BLOCKED_WOWLAN: WOWLAN is preventing the enablement of EMLSR 362 * @IWL_MVM_ESR_BLOCKED_TPT: block EMLSR when there is not enough traffic 363 * @IWL_MVM_ESR_BLOCKED_FW: FW didn't recommended/forced exit from EMLSR 364 * @IWL_MVM_ESR_BLOCKED_NON_BSS: An active non-bssid link's preventing EMLSR 365 * @IWL_MVM_ESR_EXIT_MISSED_BEACON: exited EMLSR due to missed beacons 366 * @IWL_MVM_ESR_EXIT_LOW_RSSI: link is deactivated/not allowed for EMLSR 367 * due to low RSSI. 368 * @IWL_MVM_ESR_EXIT_COEX: link is deactivated/not allowed for EMLSR 369 * due to BT Coex. 370 * @IWL_MVM_ESR_EXIT_BANDWIDTH: Bandwidths of primary and secondry links 371 * preventing the enablement of EMLSR 372 * @IWL_MVM_ESR_EXIT_CSA: CSA happened, so exit EMLSR 373 * @IWL_MVM_ESR_EXIT_LINK_USAGE: Exit EMLSR due to low tpt on secondary link 374 */ 375 enum iwl_mvm_esr_state { 376 IWL_MVM_ESR_BLOCKED_PREVENTION = 0x1, 377 IWL_MVM_ESR_BLOCKED_WOWLAN = 0x2, 378 IWL_MVM_ESR_BLOCKED_TPT = 0x4, 379 IWL_MVM_ESR_BLOCKED_FW = 0x8, 380 IWL_MVM_ESR_BLOCKED_NON_BSS = 0x10, 381 IWL_MVM_ESR_EXIT_MISSED_BEACON = 0x10000, 382 IWL_MVM_ESR_EXIT_LOW_RSSI = 0x20000, 383 IWL_MVM_ESR_EXIT_COEX = 0x40000, 384 IWL_MVM_ESR_EXIT_BANDWIDTH = 0x80000, 385 IWL_MVM_ESR_EXIT_CSA = 0x100000, 386 IWL_MVM_ESR_EXIT_LINK_USAGE = 0x200000, 387 }; 388 389 #define IWL_MVM_BLOCK_ESR_REASONS 0xffff 390 391 const char *iwl_get_esr_state_string(enum iwl_mvm_esr_state state); 392 393 /** 394 * struct iwl_mvm_esr_exit - details of the last exit from EMLSR mode. 395 * @reason: The reason for the last exit from EMLSR. 396 * &iwl_mvm_prevent_esr_reasons. Will be 0 before exiting EMLSR. 397 * @ts: the time stamp of the last time we existed EMLSR. 398 */ 399 struct iwl_mvm_esr_exit { 400 unsigned long ts; 401 enum iwl_mvm_esr_state reason; 402 }; 403 404 /** 405 * struct iwl_mvm_vif - data per Virtual Interface, it is a MAC context 406 * @mvm: pointer back to the mvm struct 407 * @id: between 0 and 3 408 * @color: to solve races upon MAC addition and removal 409 * @associated: indicates that we're currently associated, used only for 410 * managing the firmware state in iwl_mvm_bss_info_changed_station() 411 * @ap_assoc_sta_count: count of stations associated to us - valid only 412 * if VIF type is AP 413 * @uploaded: indicates the MAC context has been added to the device 414 * @ap_ibss_active: indicates that AP/IBSS is configured and that the interface 415 * should get quota etc. 416 * @pm_enabled - indicate if MAC power management is allowed 417 * @monitor_active: indicates that monitor context is configured, and that the 418 * interface should get quota etc. 419 * @low_latency: bit flags for low latency 420 * see enum &iwl_mvm_low_latency_cause for causes. 421 * @low_latency_actual: boolean, indicates low latency is set, 422 * as a result from low_latency bit flags and takes force into account. 423 * @authorized: indicates the AP station was set to authorized 424 * @ps_disabled: indicates that this interface requires PS to be disabled 425 * @csa_countdown: indicates that CSA countdown may be started 426 * @csa_failed: CSA failed to schedule time event, report an error later 427 * @csa_bcn_pending: indicates that we are waiting for a beacon on a new channel 428 * @csa_blocks_tx: CSA is blocking TX 429 * @features: hw features active for this vif 430 * @max_tx_op: max TXOP in usecs for all ACs, zero for no limit. 431 * @ap_beacon_time: AP beacon time for synchronisation (on older FW) 432 * @bf_enabled: indicates if beacon filtering is enabled 433 * @ba_enabled: indicated if beacon abort is enabled 434 * @bcn_prot: beacon protection data (keys; FIXME: needs to be per link) 435 * @deflink: default link data for use in non-MLO 436 * @link: link data for each link in MLO 437 * @esr_active: indicates eSR mode is active 438 * @esr_disable_reason: a bitmap of &enum iwl_mvm_esr_state 439 * @pm_enabled: indicates powersave is enabled 440 * @link_selection_res: bitmap of active links as it was decided in the last 441 * link selection. Valid only for a MLO vif after assoc. 0 if there wasn't 442 * any link selection yet. 443 * @link_selection_primary: primary link selected by link selection 444 * @primary_link: primary link in eSR. Valid only for an associated MLD vif, 445 * and in eSR mode. Valid only for a STA. 446 * @last_esr_exit: Details of the last exit from EMLSR. 447 * @exit_same_reason_count: The number of times we exited due to the specified 448 * @last_esr_exit::reason, only counting exits due to 449 * &IWL_MVM_ESR_PREVENT_REASONS. 450 * @prevent_esr_done_wk: work that should be done when esr prevention ends. 451 * @mlo_int_scan_wk: work for the internal MLO scan. 452 * @unblock_esr_tpt_wk: work for unblocking EMLSR when tpt is high enough. 453 */ 454 struct iwl_mvm_vif { 455 struct iwl_mvm *mvm; 456 u16 id; 457 u16 color; 458 459 bool associated; 460 u8 ap_assoc_sta_count; 461 bool uploaded; 462 bool ap_ibss_active; 463 bool pm_enabled; 464 bool monitor_active; 465 bool esr_active; 466 467 u8 low_latency: 6; 468 u8 low_latency_actual: 1; 469 470 u8 authorized:1; 471 bool ps_disabled; 472 473 u32 esr_disable_reason; 474 u32 ap_beacon_time; 475 bool bf_enabled; 476 bool ba_enabled; 477 478 #ifdef CONFIG_PM 479 /* WoWLAN GTK rekey data */ 480 struct { 481 u8 kck[NL80211_KCK_EXT_LEN]; 482 u8 kek[NL80211_KEK_EXT_LEN]; 483 size_t kek_len; 484 size_t kck_len; 485 u32 akm; 486 __le64 replay_ctr; 487 bool valid; 488 } rekey_data; 489 490 int tx_key_idx; 491 492 bool seqno_valid; 493 u16 seqno; 494 #endif 495 496 #if IS_ENABLED(CONFIG_IPV6) 497 /* IPv6 addresses for WoWLAN */ 498 struct in6_addr target_ipv6_addrs[IWL_PROTO_OFFLOAD_NUM_IPV6_ADDRS_MAX]; 499 unsigned long tentative_addrs[BITS_TO_LONGS(IWL_PROTO_OFFLOAD_NUM_IPV6_ADDRS_MAX)]; 500 int num_target_ipv6_addrs; 501 #endif 502 503 #ifdef CONFIG_IWLWIFI_DEBUGFS 504 struct dentry *dbgfs_dir; 505 struct dentry *dbgfs_slink; 506 struct iwl_dbgfs_pm dbgfs_pm; 507 struct iwl_dbgfs_bf dbgfs_bf; 508 struct iwl_mac_power_cmd mac_pwr_cmd; 509 int dbgfs_quota_min; 510 bool ftm_unprotected; 511 #endif 512 513 /* FW identified misbehaving AP */ 514 u8 uapsd_misbehaving_ap_addr[ETH_ALEN] __aligned(2); 515 struct delayed_work uapsd_nonagg_detected_wk; 516 517 bool csa_countdown; 518 bool csa_failed; 519 bool csa_bcn_pending; 520 bool csa_blocks_tx; 521 u16 csa_target_freq; 522 u16 csa_count; 523 u16 csa_misbehave; 524 struct delayed_work csa_work; 525 526 enum iwl_tsf_id tsf_id; 527 528 struct iwl_mvm_time_event_data time_event_data; 529 struct iwl_mvm_time_event_data hs_time_event_data; 530 531 /* TCP Checksum Offload */ 532 netdev_features_t features; 533 534 struct ieee80211_sta *ap_sta; 535 536 /* we can only have 2 GTK + 2 IGTK active at a time */ 537 struct ieee80211_key_conf *ap_early_keys[4]; 538 539 struct { 540 struct ieee80211_key_conf __rcu *keys[2]; 541 } bcn_prot; 542 543 u16 max_tx_op; 544 545 u16 link_selection_res; 546 u8 link_selection_primary; 547 u8 primary_link; 548 struct iwl_mvm_esr_exit last_esr_exit; 549 u8 exit_same_reason_count; 550 struct wiphy_delayed_work prevent_esr_done_wk; 551 struct wiphy_delayed_work mlo_int_scan_wk; 552 struct wiphy_work unblock_esr_tpt_wk; 553 554 struct iwl_mvm_vif_link_info deflink; 555 struct iwl_mvm_vif_link_info *link[IEEE80211_MLD_MAX_NUM_LINKS]; 556 }; 557 558 #define for_each_mvm_vif_valid_link(mvm_vif, link_id) \ 559 for (link_id = 0; \ 560 link_id < ARRAY_SIZE((mvm_vif)->link); \ 561 link_id++) \ 562 if ((mvm_vif)->link[link_id]) 563 564 static inline struct iwl_mvm_vif * 565 iwl_mvm_vif_from_mac80211(struct ieee80211_vif *vif) 566 { 567 return (void *)vif->drv_priv; 568 } 569 570 extern const u8 tid_to_mac80211_ac[]; 571 572 #define IWL_MVM_SCAN_STOPPING_SHIFT 8 573 574 enum iwl_scan_status { 575 IWL_MVM_SCAN_REGULAR = BIT(0), 576 IWL_MVM_SCAN_SCHED = BIT(1), 577 IWL_MVM_SCAN_NETDETECT = BIT(2), 578 IWL_MVM_SCAN_INT_MLO = BIT(3), 579 580 IWL_MVM_SCAN_STOPPING_REGULAR = BIT(8), 581 IWL_MVM_SCAN_STOPPING_SCHED = BIT(9), 582 IWL_MVM_SCAN_STOPPING_NETDETECT = BIT(10), 583 IWL_MVM_SCAN_STOPPING_INT_MLO = BIT(11), 584 585 IWL_MVM_SCAN_REGULAR_MASK = IWL_MVM_SCAN_REGULAR | 586 IWL_MVM_SCAN_STOPPING_REGULAR, 587 IWL_MVM_SCAN_SCHED_MASK = IWL_MVM_SCAN_SCHED | 588 IWL_MVM_SCAN_STOPPING_SCHED, 589 IWL_MVM_SCAN_NETDETECT_MASK = IWL_MVM_SCAN_NETDETECT | 590 IWL_MVM_SCAN_STOPPING_NETDETECT, 591 IWL_MVM_SCAN_INT_MLO_MASK = IWL_MVM_SCAN_INT_MLO | 592 IWL_MVM_SCAN_STOPPING_INT_MLO, 593 594 IWL_MVM_SCAN_STOPPING_MASK = 0xff << IWL_MVM_SCAN_STOPPING_SHIFT, 595 IWL_MVM_SCAN_MASK = 0xff, 596 }; 597 598 enum iwl_mvm_scan_type { 599 IWL_SCAN_TYPE_NOT_SET, 600 IWL_SCAN_TYPE_UNASSOC, 601 IWL_SCAN_TYPE_WILD, 602 IWL_SCAN_TYPE_MILD, 603 IWL_SCAN_TYPE_FRAGMENTED, 604 IWL_SCAN_TYPE_FAST_BALANCE, 605 }; 606 607 enum iwl_mvm_sched_scan_pass_all_states { 608 SCHED_SCAN_PASS_ALL_DISABLED, 609 SCHED_SCAN_PASS_ALL_ENABLED, 610 SCHED_SCAN_PASS_ALL_FOUND, 611 }; 612 613 /** 614 * struct iwl_mvm_tt_mgnt - Thermal Throttling Management structure 615 * @ct_kill_exit: worker to exit thermal kill 616 * @dynamic_smps: Is thermal throttling enabled dynamic_smps? 617 * @tx_backoff: The current thremal throttling tx backoff in uSec. 618 * @min_backoff: The minimal tx backoff due to power restrictions 619 * @params: Parameters to configure the thermal throttling algorithm. 620 * @throttle: Is thermal throttling is active? 621 */ 622 struct iwl_mvm_tt_mgmt { 623 struct delayed_work ct_kill_exit; 624 bool dynamic_smps; 625 u32 tx_backoff; 626 u32 min_backoff; 627 struct iwl_tt_params params; 628 bool throttle; 629 }; 630 631 #ifdef CONFIG_THERMAL 632 /** 633 * struct iwl_mvm_thermal_device - thermal zone related data 634 * @trips: temperature thresholds for report 635 * @tzone: thermal zone device data 636 */ 637 struct iwl_mvm_thermal_device { 638 struct thermal_trip trips[IWL_MAX_DTS_TRIPS]; 639 struct thermal_zone_device *tzone; 640 }; 641 642 /* 643 * struct iwl_mvm_cooling_device 644 * @cur_state: current state 645 * @cdev: struct thermal cooling device 646 */ 647 struct iwl_mvm_cooling_device { 648 u32 cur_state; 649 struct thermal_cooling_device *cdev; 650 }; 651 #endif 652 653 #define IWL_MVM_NUM_LAST_FRAMES_UCODE_RATES 8 654 655 struct iwl_mvm_frame_stats { 656 u32 legacy_frames; 657 u32 ht_frames; 658 u32 vht_frames; 659 u32 bw_20_frames; 660 u32 bw_40_frames; 661 u32 bw_80_frames; 662 u32 bw_160_frames; 663 u32 sgi_frames; 664 u32 ngi_frames; 665 u32 siso_frames; 666 u32 mimo2_frames; 667 u32 agg_frames; 668 u32 ampdu_count; 669 u32 success_frames; 670 u32 fail_frames; 671 u32 last_rates[IWL_MVM_NUM_LAST_FRAMES_UCODE_RATES]; 672 int last_frame_idx; 673 }; 674 675 #define IWL_MVM_DEBUG_SET_TEMPERATURE_DISABLE 0xff 676 #define IWL_MVM_DEBUG_SET_TEMPERATURE_MIN -100 677 #define IWL_MVM_DEBUG_SET_TEMPERATURE_MAX 200 678 679 enum iwl_mvm_tdls_cs_state { 680 IWL_MVM_TDLS_SW_IDLE = 0, 681 IWL_MVM_TDLS_SW_REQ_SENT, 682 IWL_MVM_TDLS_SW_RESP_RCVD, 683 IWL_MVM_TDLS_SW_REQ_RCVD, 684 IWL_MVM_TDLS_SW_ACTIVE, 685 }; 686 687 enum iwl_mvm_traffic_load { 688 IWL_MVM_TRAFFIC_LOW, 689 IWL_MVM_TRAFFIC_MEDIUM, 690 IWL_MVM_TRAFFIC_HIGH, 691 }; 692 693 DECLARE_EWMA(rate, 16, 16) 694 695 struct iwl_mvm_tcm_mac { 696 struct { 697 u32 pkts[IEEE80211_NUM_ACS]; 698 u32 airtime; 699 } tx; 700 struct { 701 u32 pkts[IEEE80211_NUM_ACS]; 702 u32 airtime; 703 u32 last_ampdu_ref; 704 } rx; 705 struct { 706 /* track AP's transfer in client mode */ 707 u64 rx_bytes; 708 struct ewma_rate rate; 709 bool detected; 710 } uapsd_nonagg_detect; 711 bool opened_rx_ba_sessions; 712 }; 713 714 struct iwl_mvm_tcm { 715 struct delayed_work work; 716 spinlock_t lock; /* used when time elapsed */ 717 unsigned long ts; /* timestamp when period ends */ 718 unsigned long ll_ts; 719 unsigned long uapsd_nonagg_ts; 720 bool paused; 721 struct iwl_mvm_tcm_mac data[NUM_MAC_INDEX_DRIVER]; 722 struct { 723 u32 elapsed; /* milliseconds for this TCM period */ 724 u32 airtime[NUM_MAC_INDEX_DRIVER]; 725 enum iwl_mvm_traffic_load load[NUM_MAC_INDEX_DRIVER]; 726 enum iwl_mvm_traffic_load band_load[NUM_NL80211_BANDS]; 727 enum iwl_mvm_traffic_load global_load; 728 bool low_latency[NUM_MAC_INDEX_DRIVER]; 729 bool change[NUM_MAC_INDEX_DRIVER]; 730 } result; 731 }; 732 733 /** 734 * struct iwl_mvm_reorder_buffer - per ra/tid/queue reorder buffer 735 * @head_sn: reorder window head sn 736 * @num_stored: number of mpdus stored in the buffer 737 * @buf_size: the reorder buffer size as set by the last addba request 738 * @queue: queue of this reorder buffer 739 * @last_amsdu: track last ASMDU SN for duplication detection 740 * @last_sub_index: track ASMDU sub frame index for duplication detection 741 * @valid: reordering is valid for this queue 742 * @lock: protect reorder buffer internal state 743 * @mvm: mvm pointer, needed for frame timer context 744 */ 745 struct iwl_mvm_reorder_buffer { 746 u16 head_sn; 747 u16 num_stored; 748 u16 buf_size; 749 int queue; 750 u16 last_amsdu; 751 u8 last_sub_index; 752 bool valid; 753 spinlock_t lock; 754 struct iwl_mvm *mvm; 755 } ____cacheline_aligned_in_smp; 756 757 /** 758 * struct iwl_mvm_reorder_buf_entry - reorder buffer entry per-queue/per-seqno 759 * @frames: list of skbs stored 760 */ 761 struct iwl_mvm_reorder_buf_entry { 762 struct sk_buff_head frames; 763 } 764 #ifndef __CHECKER__ 765 /* sparse doesn't like this construct: "bad integer constant expression" */ 766 __aligned(roundup_pow_of_two(sizeof(struct sk_buff_head))) 767 #endif 768 ; 769 770 /** 771 * struct iwl_mvm_baid_data - BA session data 772 * @sta_mask: current station mask for the BAID 773 * @tid: tid of the session 774 * @baid: baid of the session 775 * @timeout: the timeout set in the addba request 776 * @entries_per_queue: # of buffers per queue, this actually gets 777 * aligned up to avoid cache line sharing between queues 778 * @last_rx: last rx jiffies, updated only if timeout passed from last update 779 * @session_timer: timer to check if BA session expired, runs at 2 * timeout 780 * @rcu_ptr: BA data RCU protected access 781 * @rcu_head: RCU head for freeing this data 782 * @mvm: mvm pointer, needed for timer context 783 * @reorder_buf: reorder buffer, allocated per queue 784 * @entries: data 785 */ 786 struct iwl_mvm_baid_data { 787 struct rcu_head rcu_head; 788 u32 sta_mask; 789 u8 tid; 790 u8 baid; 791 u16 timeout; 792 u16 entries_per_queue; 793 unsigned long last_rx; 794 struct timer_list session_timer; 795 struct iwl_mvm_baid_data __rcu **rcu_ptr; 796 struct iwl_mvm *mvm; 797 struct iwl_mvm_reorder_buffer reorder_buf[IWL_MAX_RX_HW_QUEUES]; 798 struct iwl_mvm_reorder_buf_entry entries[]; 799 }; 800 801 static inline struct iwl_mvm_baid_data * 802 iwl_mvm_baid_data_from_reorder_buf(struct iwl_mvm_reorder_buffer *buf) 803 { 804 return (void *)((u8 *)buf - 805 offsetof(struct iwl_mvm_baid_data, reorder_buf) - 806 sizeof(*buf) * buf->queue); 807 } 808 809 /* 810 * enum iwl_mvm_queue_status - queue status 811 * @IWL_MVM_QUEUE_FREE: the queue is not allocated nor reserved 812 * Basically, this means that this queue can be used for any purpose 813 * @IWL_MVM_QUEUE_RESERVED: queue is reserved but not yet in use 814 * This is the state of a queue that has been dedicated for some RATID 815 * (agg'd or not), but that hasn't yet gone through the actual enablement 816 * of iwl_mvm_enable_txq(), and therefore no traffic can go through it yet. 817 * Note that in this state there is no requirement to already know what TID 818 * should be used with this queue, it is just marked as a queue that will 819 * be used, and shouldn't be allocated to anyone else. 820 * @IWL_MVM_QUEUE_READY: queue is ready to be used 821 * This is the state of a queue that has been fully configured (including 822 * SCD pointers, etc), has a specific RA/TID assigned to it, and can be 823 * used to send traffic. 824 * @IWL_MVM_QUEUE_SHARED: queue is shared, or in a process of becoming shared 825 * This is a state in which a single queue serves more than one TID, all of 826 * which are not aggregated. Note that the queue is only associated to one 827 * RA. 828 */ 829 enum iwl_mvm_queue_status { 830 IWL_MVM_QUEUE_FREE, 831 IWL_MVM_QUEUE_RESERVED, 832 IWL_MVM_QUEUE_READY, 833 IWL_MVM_QUEUE_SHARED, 834 }; 835 836 #define IWL_MVM_DQA_QUEUE_TIMEOUT (5 * HZ) 837 #define IWL_MVM_INVALID_QUEUE 0xFFFF 838 839 #define IWL_MVM_NUM_CIPHERS 10 840 841 842 struct iwl_mvm_txq { 843 struct list_head list; 844 u16 txq_id; 845 atomic_t tx_request; 846 #define IWL_MVM_TXQ_STATE_READY 0 847 #define IWL_MVM_TXQ_STATE_STOP_FULL 1 848 #define IWL_MVM_TXQ_STATE_STOP_REDIRECT 2 849 #define IWL_MVM_TXQ_STATE_STOP_AP_CSA 3 850 unsigned long state; 851 }; 852 853 static inline struct iwl_mvm_txq * 854 iwl_mvm_txq_from_mac80211(struct ieee80211_txq *txq) 855 { 856 return (void *)txq->drv_priv; 857 } 858 859 static inline struct iwl_mvm_txq * 860 iwl_mvm_txq_from_tid(struct ieee80211_sta *sta, u8 tid) 861 { 862 if (tid == IWL_MAX_TID_COUNT) 863 tid = IEEE80211_NUM_TIDS; 864 865 return (void *)sta->txq[tid]->drv_priv; 866 } 867 868 /** 869 * struct iwl_mvm_tvqm_txq_info - maps TVQM hw queue to tid 870 * 871 * @sta_id: sta id 872 * @txq_tid: txq tid 873 */ 874 struct iwl_mvm_tvqm_txq_info { 875 u8 sta_id; 876 u8 txq_tid; 877 }; 878 879 struct iwl_mvm_dqa_txq_info { 880 u8 ra_sta_id; /* The RA this queue is mapped to, if exists */ 881 bool reserved; /* Is this the TXQ reserved for a STA */ 882 u8 mac80211_ac; /* The mac80211 AC this queue is mapped to */ 883 u8 txq_tid; /* The TID "owner" of this queue*/ 884 u16 tid_bitmap; /* Bitmap of the TIDs mapped to this queue */ 885 /* Timestamp for inactivation per TID of this queue */ 886 unsigned long last_frame_time[IWL_MAX_TID_COUNT + 1]; 887 enum iwl_mvm_queue_status status; 888 }; 889 890 struct ptp_data { 891 struct ptp_clock *ptp_clock; 892 struct ptp_clock_info ptp_clock_info; 893 894 struct delayed_work dwork; 895 896 /* The last GP2 reading from the hw */ 897 u32 last_gp2; 898 899 /* number of wraparounds since scale_update_adj_time_ns */ 900 u32 wrap_counter; 901 902 /* GP2 time when the scale was last updated */ 903 u32 scale_update_gp2; 904 905 /* Adjusted time when the scale was last updated in nanoseconds */ 906 u64 scale_update_adj_time_ns; 907 908 /* clock frequency offset, scaled to 65536000000 */ 909 u64 scaled_freq; 910 911 /* Delta between hardware clock and ptp clock in nanoseconds */ 912 s64 delta; 913 }; 914 915 struct iwl_time_sync_data { 916 struct sk_buff_head frame_list; 917 u8 peer_addr[ETH_ALEN]; 918 bool active; 919 }; 920 921 struct iwl_mei_scan_filter { 922 bool is_mei_limited_scan; 923 struct sk_buff_head scan_res; 924 struct work_struct scan_work; 925 }; 926 927 /** 928 * struct iwl_mvm_acs_survey_channel - per-channel survey information 929 * 930 * Stripped down version of &struct survey_info. 931 * 932 * @time: time in ms the radio was on the channel 933 * @time_busy: time in ms the channel was sensed busy 934 * @time_tx: time in ms spent transmitting data 935 * @time_rx: time in ms spent receiving data 936 * @noise: channel noise in dBm 937 */ 938 struct iwl_mvm_acs_survey_channel { 939 u32 time; 940 u32 time_busy; 941 u32 time_tx; 942 u32 time_rx; 943 s8 noise; 944 }; 945 946 struct iwl_mvm_acs_survey { 947 struct iwl_mvm_acs_survey_channel *bands[NUM_NL80211_BANDS]; 948 949 /* Overall number of channels */ 950 int n_channels; 951 952 /* Storage space for per-channel information follows */ 953 struct iwl_mvm_acs_survey_channel channels[] __counted_by(n_channels); 954 }; 955 956 struct iwl_mvm { 957 /* for logger access */ 958 struct device *dev; 959 960 struct iwl_trans *trans; 961 const struct iwl_fw *fw; 962 const struct iwl_cfg *cfg; 963 struct iwl_phy_db *phy_db; 964 struct ieee80211_hw *hw; 965 966 /* for protecting access to iwl_mvm */ 967 struct mutex mutex; 968 struct list_head async_handlers_list; 969 spinlock_t async_handlers_lock; 970 struct work_struct async_handlers_wk; 971 972 /* For async rx handlers that require the wiphy lock */ 973 struct wiphy_work async_handlers_wiphy_wk; 974 975 struct wiphy_work trig_link_selection_wk; 976 977 struct work_struct roc_done_wk; 978 979 unsigned long init_status; 980 981 unsigned long status; 982 983 u32 queue_sync_cookie; 984 unsigned long queue_sync_state; 985 /* 986 * for beacon filtering - 987 * currently only one interface can be supported 988 */ 989 struct iwl_mvm_vif *bf_allowed_vif; 990 991 bool hw_registered; 992 bool rfkill_safe_init_done; 993 994 u8 cca_40mhz_workaround; 995 996 u32 ampdu_ref; 997 bool ampdu_toggle; 998 999 struct iwl_notif_wait_data notif_wait; 1000 1001 union { 1002 struct mvm_statistics_rx_v3 rx_stats_v3; 1003 struct mvm_statistics_rx rx_stats; 1004 }; 1005 1006 struct { 1007 u64 rx_time; 1008 u64 tx_time; 1009 u64 on_time_rf; 1010 u64 on_time_scan; 1011 } radio_stats, accu_radio_stats; 1012 1013 struct list_head add_stream_txqs; 1014 union { 1015 struct iwl_mvm_dqa_txq_info queue_info[IWL_MAX_HW_QUEUES]; 1016 struct iwl_mvm_tvqm_txq_info tvqm_info[IWL_MAX_TVQM_QUEUES]; 1017 }; 1018 struct work_struct add_stream_wk; /* To add streams to queues */ 1019 spinlock_t add_stream_lock; 1020 1021 const char *nvm_file_name; 1022 struct iwl_nvm_data *nvm_data; 1023 struct iwl_mei_nvm *mei_nvm_data; 1024 struct iwl_mvm_csme_conn_info __rcu *csme_conn_info; 1025 bool mei_rfkill_blocked; 1026 bool mei_registered; 1027 struct work_struct sap_connected_wk; 1028 1029 /* 1030 * NVM built based on the SAP data but that we can't free even after 1031 * we get ownership because it contains the cfg80211's channel. 1032 */ 1033 struct iwl_nvm_data *temp_nvm_data; 1034 1035 /* NVM sections */ 1036 struct iwl_nvm_section nvm_sections[NVM_MAX_NUM_SECTIONS]; 1037 1038 struct iwl_fw_runtime fwrt; 1039 1040 /* EEPROM MAC addresses */ 1041 struct mac_address addresses[IWL_MVM_MAX_ADDRESSES]; 1042 1043 /* data related to data path */ 1044 struct iwl_rx_phy_info last_phy_info; 1045 struct ieee80211_sta __rcu *fw_id_to_mac_id[IWL_MVM_STATION_COUNT_MAX]; 1046 struct ieee80211_link_sta __rcu *fw_id_to_link_sta[IWL_MVM_STATION_COUNT_MAX]; 1047 u8 rx_ba_sessions; 1048 1049 /* configured by mac80211 */ 1050 u32 rts_threshold; 1051 1052 /* Scan status, cmd (pre-allocated) and auxiliary station */ 1053 unsigned int scan_status; 1054 size_t scan_cmd_size; 1055 void *scan_cmd; 1056 struct iwl_mcast_filter_cmd *mcast_filter_cmd; 1057 /* For CDB this is low band scan type, for non-CDB - type. */ 1058 enum iwl_mvm_scan_type scan_type; 1059 enum iwl_mvm_scan_type hb_scan_type; 1060 1061 enum iwl_mvm_sched_scan_pass_all_states sched_scan_pass_all; 1062 struct delayed_work scan_timeout_dwork; 1063 1064 /* max number of simultaneous scans the FW supports */ 1065 unsigned int max_scans; 1066 1067 /* UMAC scan tracking */ 1068 u32 scan_uid_status[IWL_MVM_MAX_UMAC_SCANS]; 1069 1070 /* start time of last scan in TSF of the mac that requested the scan */ 1071 u64 scan_start; 1072 1073 /* the vif that requested the current scan */ 1074 struct iwl_mvm_vif *scan_vif; 1075 u8 scan_link_id; 1076 1077 /* rx chain antennas set through debugfs for the scan command */ 1078 u8 scan_rx_ant; 1079 1080 /* Internal station */ 1081 struct iwl_mvm_int_sta aux_sta; 1082 struct iwl_mvm_int_sta snif_sta; 1083 1084 bool last_ebs_successful; 1085 1086 u8 scan_last_antenna_idx; /* to toggle TX between antennas */ 1087 u8 mgmt_last_antenna_idx; 1088 1089 u8 set_tx_ant; 1090 u8 set_rx_ant; 1091 1092 /* last smart fifo state that was successfully sent to firmware */ 1093 enum iwl_sf_state sf_state; 1094 1095 /* 1096 * Leave this pointer outside the ifdef below so that it can be 1097 * assigned without ifdef in the source code. 1098 */ 1099 struct dentry *debugfs_dir; 1100 #ifdef CONFIG_IWLWIFI_DEBUGFS 1101 u32 dbgfs_sram_offset, dbgfs_sram_len; 1102 u32 dbgfs_prph_reg_addr; 1103 bool disable_power_off; 1104 bool disable_power_off_d3; 1105 bool beacon_inject_active; 1106 1107 bool scan_iter_notif_enabled; 1108 1109 struct debugfs_blob_wrapper nvm_hw_blob; 1110 struct debugfs_blob_wrapper nvm_sw_blob; 1111 struct debugfs_blob_wrapper nvm_calib_blob; 1112 struct debugfs_blob_wrapper nvm_prod_blob; 1113 struct debugfs_blob_wrapper nvm_phy_sku_blob; 1114 struct debugfs_blob_wrapper nvm_reg_blob; 1115 1116 struct iwl_mvm_frame_stats drv_rx_stats; 1117 spinlock_t drv_stats_lock; 1118 u16 dbgfs_rx_phyinfo; 1119 #endif 1120 1121 struct iwl_mvm_phy_ctxt phy_ctxts[NUM_PHY_CTX]; 1122 1123 struct list_head time_event_list; 1124 spinlock_t time_event_lock; 1125 1126 /* 1127 * A bitmap indicating the index of the key in use. The firmware 1128 * can hold 16 keys at most. Reflect this fact. 1129 */ 1130 unsigned long fw_key_table[BITS_TO_LONGS(STA_KEY_MAX_NUM)]; 1131 u8 fw_key_deleted[STA_KEY_MAX_NUM]; 1132 1133 struct ieee80211_vif __rcu *vif_id_to_mac[NUM_MAC_INDEX_DRIVER]; 1134 1135 struct ieee80211_bss_conf __rcu *link_id_to_link_conf[IWL_MVM_FW_MAX_LINK_ID + 1]; 1136 1137 /* -1 for always, 0 for never, >0 for that many times */ 1138 s8 fw_restart; 1139 u8 *error_recovery_buf; 1140 1141 #ifdef CONFIG_IWLWIFI_LEDS 1142 struct led_classdev led; 1143 #endif 1144 1145 struct ieee80211_vif *p2p_device_vif; 1146 1147 #ifdef CONFIG_PM 1148 struct wiphy_wowlan_support wowlan; 1149 int gtk_ivlen, gtk_icvlen, ptk_ivlen, ptk_icvlen; 1150 1151 /* sched scan settings for net detect */ 1152 struct ieee80211_scan_ies nd_ies; 1153 struct cfg80211_match_set *nd_match_sets; 1154 int n_nd_match_sets; 1155 struct ieee80211_channel **nd_channels; 1156 int n_nd_channels; 1157 bool net_detect; 1158 u8 offload_tid; 1159 #ifdef CONFIG_IWLWIFI_DEBUGFS 1160 bool d3_wake_sysassert; 1161 bool d3_test_active; 1162 u32 d3_test_pme_ptr; 1163 struct ieee80211_vif *keep_vif; 1164 u32 last_netdetect_scans; /* no. of scans in the last net-detect wake */ 1165 #endif 1166 #endif 1167 1168 wait_queue_head_t rx_sync_waitq; 1169 1170 /* BT-Coex */ 1171 struct iwl_bt_coex_profile_notif last_bt_notif; 1172 struct iwl_bt_coex_ci_cmd last_bt_ci_cmd; 1173 1174 u8 bt_tx_prio; 1175 enum iwl_bt_force_ant_mode bt_force_ant_mode; 1176 1177 /* Aux ROC */ 1178 struct list_head aux_roc_te_list; 1179 1180 /* Thermal Throttling and CTkill */ 1181 struct iwl_mvm_tt_mgmt thermal_throttle; 1182 #ifdef CONFIG_THERMAL 1183 struct iwl_mvm_thermal_device tz_device; 1184 struct iwl_mvm_cooling_device cooling_dev; 1185 #endif 1186 1187 s32 temperature; /* Celsius */ 1188 /* 1189 * Debug option to set the NIC temperature. This option makes the 1190 * driver think this is the actual NIC temperature, and ignore the 1191 * real temperature that is received from the fw 1192 */ 1193 bool temperature_test; /* Debug test temperature is enabled */ 1194 1195 bool fw_static_smps_request; 1196 1197 unsigned long bt_coex_last_tcm_ts; 1198 struct iwl_mvm_tcm tcm; 1199 1200 u8 uapsd_noagg_bssid_write_idx; 1201 struct mac_address uapsd_noagg_bssids[IWL_MVM_UAPSD_NOAGG_BSSIDS_NUM] 1202 __aligned(2); 1203 1204 struct iwl_time_quota_cmd last_quota_cmd; 1205 1206 #ifdef CONFIG_NL80211_TESTMODE 1207 u32 noa_duration; 1208 struct ieee80211_vif *noa_vif; 1209 #endif 1210 1211 /* Tx queues */ 1212 u16 aux_queue; 1213 u16 snif_queue; 1214 u16 probe_queue; 1215 u16 p2p_dev_queue; 1216 1217 /* Indicate if device power save is allowed */ 1218 u8 ps_disabled; /* u8 instead of bool to ease debugfs_create_* usage */ 1219 /* Indicate if 32Khz external clock is valid */ 1220 u32 ext_clock_valid; 1221 1222 /* This vif used by CSME to send / receive traffic */ 1223 struct ieee80211_vif *csme_vif; 1224 struct ieee80211_vif __rcu *csa_vif; 1225 struct ieee80211_vif __rcu *csa_tx_blocked_vif; 1226 u8 csa_tx_block_bcn_timeout; 1227 1228 /* system time of last beacon (for AP/GO interface) */ 1229 u32 ap_last_beacon_gp2; 1230 1231 /* indicates that we transmitted the last beacon */ 1232 bool ibss_manager; 1233 1234 bool lar_regdom_set; 1235 enum iwl_mcc_source mcc_src; 1236 1237 /* TDLS channel switch data */ 1238 struct { 1239 struct delayed_work dwork; 1240 enum iwl_mvm_tdls_cs_state state; 1241 1242 /* 1243 * Current cs sta - might be different from periodic cs peer 1244 * station. Value is meaningless when the cs-state is idle. 1245 */ 1246 u8 cur_sta_id; 1247 1248 /* TDLS periodic channel-switch peer */ 1249 struct { 1250 u8 sta_id; 1251 u8 op_class; 1252 bool initiator; /* are we the link initiator */ 1253 struct cfg80211_chan_def chandef; 1254 struct sk_buff *skb; /* ch sw template */ 1255 u32 ch_sw_tm_ie; 1256 1257 /* timestamp of last ch-sw request sent (GP2 time) */ 1258 u32 sent_timestamp; 1259 } peer; 1260 } tdls_cs; 1261 1262 1263 u32 ciphers[IWL_MVM_NUM_CIPHERS]; 1264 1265 struct cfg80211_ftm_responder_stats ftm_resp_stats; 1266 struct { 1267 struct cfg80211_pmsr_request *req; 1268 struct wireless_dev *req_wdev; 1269 struct list_head loc_list; 1270 int responses[IWL_MVM_TOF_MAX_APS]; 1271 struct { 1272 struct list_head resp; 1273 } smooth; 1274 struct list_head pasn_list; 1275 } ftm_initiator; 1276 1277 struct list_head resp_pasn_list; 1278 1279 struct ptp_data ptp_data; 1280 1281 struct { 1282 u8 range_resp; 1283 } cmd_ver; 1284 1285 struct ieee80211_vif *nan_vif; 1286 struct iwl_mvm_baid_data __rcu *baid_map[IWL_MAX_BAID]; 1287 1288 /* 1289 * Drop beacons from other APs in AP mode when there are no connected 1290 * clients. 1291 */ 1292 bool drop_bcn_ap_mode; 1293 1294 struct delayed_work cs_tx_unblock_dwork; 1295 1296 /* does a monitor vif exist (only one can exist hence bool) */ 1297 bool monitor_on; 1298 /* 1299 * primary channel position relative to he whole bandwidth, 1300 * in steps of 80 MHz 1301 */ 1302 u8 monitor_p80; 1303 1304 /* sniffer data to include in radiotap */ 1305 __le16 cur_aid; 1306 u8 cur_bssid[ETH_ALEN]; 1307 1308 #ifdef CONFIG_ACPI 1309 struct iwl_phy_specific_cfg phy_filters; 1310 #endif 1311 1312 /* report rx timestamp in ptp clock time */ 1313 bool rx_ts_ptp; 1314 1315 unsigned long last_6ghz_passive_scan_jiffies; 1316 unsigned long last_reset_or_resume_time_jiffies; 1317 1318 bool sta_remove_requires_queue_remove; 1319 bool mld_api_is_used; 1320 1321 bool pldr_sync; 1322 1323 struct iwl_time_sync_data time_sync; 1324 1325 struct iwl_mei_scan_filter mei_scan_filter; 1326 1327 struct iwl_mvm_acs_survey *acs_survey; 1328 1329 bool statistics_clear; 1330 }; 1331 1332 /* Extract MVM priv from op_mode and _hw */ 1333 #define IWL_OP_MODE_GET_MVM(_iwl_op_mode) \ 1334 ((struct iwl_mvm *)(_iwl_op_mode)->op_mode_specific) 1335 1336 #define IWL_MAC80211_GET_MVM(_hw) \ 1337 IWL_OP_MODE_GET_MVM((struct iwl_op_mode *)((_hw)->priv)) 1338 1339 DEFINE_GUARD(mvm, struct iwl_mvm *, mutex_lock(&_T->mutex), mutex_unlock(&_T->mutex)) 1340 1341 /** 1342 * enum iwl_mvm_status - MVM status bits 1343 * @IWL_MVM_STATUS_HW_RFKILL: HW RF-kill is asserted 1344 * @IWL_MVM_STATUS_HW_CTKILL: CT-kill is active 1345 * @IWL_MVM_STATUS_ROC_RUNNING: remain-on-channel is running 1346 * @IWL_MVM_STATUS_HW_RESTART_REQUESTED: HW restart was requested 1347 * @IWL_MVM_STATUS_IN_HW_RESTART: HW restart is active 1348 * @IWL_MVM_STATUS_ROC_AUX_RUNNING: AUX remain-on-channel is running 1349 * @IWL_MVM_STATUS_FIRMWARE_RUNNING: firmware is running 1350 * @IWL_MVM_STATUS_IN_D3: in D3 (or at least about to go into it) 1351 * @IWL_MVM_STATUS_SUPPRESS_ERROR_LOG_ONCE: suppress one error log 1352 * if this is set, when intentionally triggered 1353 * @IWL_MVM_STATUS_STARTING: starting mac, 1354 * used to disable restart flow while in STARTING state 1355 */ 1356 enum iwl_mvm_status { 1357 IWL_MVM_STATUS_HW_RFKILL, 1358 IWL_MVM_STATUS_HW_CTKILL, 1359 IWL_MVM_STATUS_ROC_RUNNING, 1360 IWL_MVM_STATUS_HW_RESTART_REQUESTED, 1361 IWL_MVM_STATUS_IN_HW_RESTART, 1362 IWL_MVM_STATUS_ROC_AUX_RUNNING, 1363 IWL_MVM_STATUS_FIRMWARE_RUNNING, 1364 IWL_MVM_STATUS_IN_D3, 1365 IWL_MVM_STATUS_SUPPRESS_ERROR_LOG_ONCE, 1366 IWL_MVM_STATUS_STARTING, 1367 }; 1368 1369 struct iwl_mvm_csme_conn_info { 1370 struct rcu_head rcu_head; 1371 struct iwl_mei_conn_info conn_info; 1372 }; 1373 1374 /* Keep track of completed init configuration */ 1375 enum iwl_mvm_init_status { 1376 IWL_MVM_INIT_STATUS_THERMAL_INIT_COMPLETE = BIT(0), 1377 IWL_MVM_INIT_STATUS_LEDS_INIT_COMPLETE = BIT(1), 1378 }; 1379 1380 static inline bool iwl_mvm_is_radio_killed(struct iwl_mvm *mvm) 1381 { 1382 return test_bit(IWL_MVM_STATUS_HW_RFKILL, &mvm->status) || 1383 test_bit(IWL_MVM_STATUS_HW_CTKILL, &mvm->status); 1384 } 1385 1386 static inline bool iwl_mvm_is_radio_hw_killed(struct iwl_mvm *mvm) 1387 { 1388 return test_bit(IWL_MVM_STATUS_HW_RFKILL, &mvm->status); 1389 } 1390 1391 static inline bool iwl_mvm_firmware_running(struct iwl_mvm *mvm) 1392 { 1393 return test_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING, &mvm->status); 1394 } 1395 1396 /* Must be called with rcu_read_lock() held and it can only be 1397 * released when mvmsta is not needed anymore. 1398 */ 1399 static inline struct iwl_mvm_sta * 1400 iwl_mvm_sta_from_staid_rcu(struct iwl_mvm *mvm, u8 sta_id) 1401 { 1402 struct ieee80211_sta *sta; 1403 1404 if (sta_id >= mvm->fw->ucode_capa.num_stations) 1405 return NULL; 1406 1407 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]); 1408 1409 /* This can happen if the station has been removed right now */ 1410 if (IS_ERR_OR_NULL(sta)) 1411 return NULL; 1412 1413 return iwl_mvm_sta_from_mac80211(sta); 1414 } 1415 1416 static inline struct iwl_mvm_sta * 1417 iwl_mvm_sta_from_staid_protected(struct iwl_mvm *mvm, u8 sta_id) 1418 { 1419 struct ieee80211_sta *sta; 1420 1421 if (sta_id >= mvm->fw->ucode_capa.num_stations) 1422 return NULL; 1423 1424 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id], 1425 lockdep_is_held(&mvm->mutex)); 1426 1427 /* This can happen if the station has been removed right now */ 1428 if (IS_ERR_OR_NULL(sta)) 1429 return NULL; 1430 1431 return iwl_mvm_sta_from_mac80211(sta); 1432 } 1433 1434 static inline struct ieee80211_vif * 1435 iwl_mvm_rcu_dereference_vif_id(struct iwl_mvm *mvm, u8 vif_id, bool rcu) 1436 { 1437 if (WARN_ON(vif_id >= ARRAY_SIZE(mvm->vif_id_to_mac))) 1438 return NULL; 1439 1440 if (rcu) 1441 return rcu_dereference(mvm->vif_id_to_mac[vif_id]); 1442 1443 return rcu_dereference_protected(mvm->vif_id_to_mac[vif_id], 1444 lockdep_is_held(&mvm->mutex)); 1445 } 1446 1447 static inline struct ieee80211_bss_conf * 1448 iwl_mvm_rcu_fw_link_id_to_link_conf(struct iwl_mvm *mvm, u8 link_id, bool rcu) 1449 { 1450 if (WARN_ON(link_id >= ARRAY_SIZE(mvm->link_id_to_link_conf))) 1451 return NULL; 1452 1453 if (rcu) 1454 return rcu_dereference(mvm->link_id_to_link_conf[link_id]); 1455 1456 return rcu_dereference_protected(mvm->link_id_to_link_conf[link_id], 1457 lockdep_is_held(&mvm->mutex)); 1458 } 1459 1460 static inline bool iwl_mvm_is_adaptive_dwell_supported(struct iwl_mvm *mvm) 1461 { 1462 return fw_has_api(&mvm->fw->ucode_capa, 1463 IWL_UCODE_TLV_API_ADAPTIVE_DWELL); 1464 } 1465 1466 static inline bool iwl_mvm_is_adaptive_dwell_v2_supported(struct iwl_mvm *mvm) 1467 { 1468 return fw_has_api(&mvm->fw->ucode_capa, 1469 IWL_UCODE_TLV_API_ADAPTIVE_DWELL_V2); 1470 } 1471 1472 static inline bool iwl_mvm_is_adwell_hb_ap_num_supported(struct iwl_mvm *mvm) 1473 { 1474 return fw_has_api(&mvm->fw->ucode_capa, 1475 IWL_UCODE_TLV_API_ADWELL_HB_DEF_N_AP); 1476 } 1477 1478 static inline bool iwl_mvm_is_oce_supported(struct iwl_mvm *mvm) 1479 { 1480 /* OCE should never be enabled for LMAC scan FWs */ 1481 return fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_OCE); 1482 } 1483 1484 static inline bool iwl_mvm_is_frag_ebs_supported(struct iwl_mvm *mvm) 1485 { 1486 return fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_FRAG_EBS); 1487 } 1488 1489 static inline bool iwl_mvm_is_short_beacon_notif_supported(struct iwl_mvm *mvm) 1490 { 1491 return fw_has_api(&mvm->fw->ucode_capa, 1492 IWL_UCODE_TLV_API_SHORT_BEACON_NOTIF); 1493 } 1494 1495 static inline bool iwl_mvm_is_dqa_data_queue(struct iwl_mvm *mvm, u8 queue) 1496 { 1497 return (queue >= IWL_MVM_DQA_MIN_DATA_QUEUE) && 1498 (queue <= IWL_MVM_DQA_MAX_DATA_QUEUE); 1499 } 1500 1501 static inline bool iwl_mvm_is_dqa_mgmt_queue(struct iwl_mvm *mvm, u8 queue) 1502 { 1503 return (queue >= IWL_MVM_DQA_MIN_MGMT_QUEUE) && 1504 (queue <= IWL_MVM_DQA_MAX_MGMT_QUEUE); 1505 } 1506 1507 static inline bool iwl_mvm_is_lar_supported(struct iwl_mvm *mvm) 1508 { 1509 bool nvm_lar = mvm->nvm_data->lar_enabled; 1510 bool tlv_lar = fw_has_capa(&mvm->fw->ucode_capa, 1511 IWL_UCODE_TLV_CAPA_LAR_SUPPORT); 1512 1513 /* 1514 * Enable LAR only if it is supported by the FW (TLV) && 1515 * enabled in the NVM 1516 */ 1517 if (mvm->cfg->nvm_type == IWL_NVM_EXT) 1518 return nvm_lar && tlv_lar; 1519 else 1520 return tlv_lar; 1521 } 1522 1523 static inline bool iwl_mvm_is_wifi_mcc_supported(struct iwl_mvm *mvm) 1524 { 1525 return fw_has_api(&mvm->fw->ucode_capa, 1526 IWL_UCODE_TLV_API_WIFI_MCC_UPDATE) || 1527 fw_has_capa(&mvm->fw->ucode_capa, 1528 IWL_UCODE_TLV_CAPA_LAR_MULTI_MCC); 1529 } 1530 1531 static inline bool iwl_mvm_bt_is_rrc_supported(struct iwl_mvm *mvm) 1532 { 1533 return fw_has_capa(&mvm->fw->ucode_capa, 1534 IWL_UCODE_TLV_CAPA_BT_COEX_RRC) && 1535 IWL_MVM_BT_COEX_RRC; 1536 } 1537 1538 static inline bool iwl_mvm_is_csum_supported(struct iwl_mvm *mvm) 1539 { 1540 return fw_has_capa(&mvm->fw->ucode_capa, 1541 IWL_UCODE_TLV_CAPA_CSUM_SUPPORT) && 1542 !IWL_MVM_HW_CSUM_DISABLE; 1543 } 1544 1545 static inline bool iwl_mvm_is_mplut_supported(struct iwl_mvm *mvm) 1546 { 1547 return fw_has_capa(&mvm->fw->ucode_capa, 1548 IWL_UCODE_TLV_CAPA_BT_MPLUT_SUPPORT) && 1549 IWL_MVM_BT_COEX_MPLUT; 1550 } 1551 1552 static inline 1553 bool iwl_mvm_is_p2p_scm_uapsd_supported(struct iwl_mvm *mvm) 1554 { 1555 return fw_has_capa(&mvm->fw->ucode_capa, 1556 IWL_UCODE_TLV_CAPA_P2P_SCM_UAPSD) && 1557 !(iwlwifi_mod_params.uapsd_disable & 1558 IWL_DISABLE_UAPSD_P2P_CLIENT); 1559 } 1560 1561 static inline bool iwl_mvm_has_new_rx_api(struct iwl_mvm *mvm) 1562 { 1563 return fw_has_capa(&mvm->fw->ucode_capa, 1564 IWL_UCODE_TLV_CAPA_MULTI_QUEUE_RX_SUPPORT); 1565 } 1566 1567 static inline bool iwl_mvm_has_mld_api(const struct iwl_fw *fw) 1568 { 1569 return fw_has_capa(&fw->ucode_capa, 1570 IWL_UCODE_TLV_CAPA_MLD_API_SUPPORT); 1571 } 1572 1573 static inline bool iwl_mvm_has_new_station_api(const struct iwl_fw *fw) 1574 { 1575 return iwl_mvm_has_mld_api(fw) || 1576 iwl_fw_lookup_cmd_ver(fw, ADD_STA, 0) >= 12; 1577 } 1578 1579 static inline bool iwl_mvm_has_new_tx_api(struct iwl_mvm *mvm) 1580 { 1581 /* TODO - replace with TLV once defined */ 1582 return mvm->trans->trans_cfg->gen2; 1583 } 1584 1585 static inline bool iwl_mvm_has_unified_ucode(struct iwl_mvm *mvm) 1586 { 1587 /* TODO - better define this */ 1588 return mvm->trans->trans_cfg->device_family >= IWL_DEVICE_FAMILY_22000; 1589 } 1590 1591 static inline bool iwl_mvm_is_cdb_supported(struct iwl_mvm *mvm) 1592 { 1593 /* 1594 * TODO: 1595 * The issue of how to determine CDB APIs and usage is still not fully 1596 * defined. 1597 * There is a compilation for CDB and non-CDB FW, but there may 1598 * be also runtime check. 1599 * For now there is a TLV for checking compilation mode, but a 1600 * runtime check will also have to be here - once defined. 1601 */ 1602 return fw_has_capa(&mvm->fw->ucode_capa, 1603 IWL_UCODE_TLV_CAPA_CDB_SUPPORT); 1604 } 1605 1606 static inline bool iwl_mvm_cdb_scan_api(struct iwl_mvm *mvm) 1607 { 1608 /* 1609 * TODO: should this be the same as iwl_mvm_is_cdb_supported()? 1610 * but then there's a little bit of code in scan that won't make 1611 * any sense... 1612 */ 1613 return mvm->trans->trans_cfg->device_family >= IWL_DEVICE_FAMILY_22000; 1614 } 1615 1616 static inline bool iwl_mvm_is_scan_ext_chan_supported(struct iwl_mvm *mvm) 1617 { 1618 return fw_has_api(&mvm->fw->ucode_capa, 1619 IWL_UCODE_TLV_API_SCAN_EXT_CHAN_VER); 1620 } 1621 1622 1623 static inline bool iwl_mvm_is_reduced_config_scan_supported(struct iwl_mvm *mvm) 1624 { 1625 return fw_has_api(&mvm->fw->ucode_capa, 1626 IWL_UCODE_TLV_API_REDUCED_SCAN_CONFIG); 1627 } 1628 1629 static inline bool iwl_mvm_is_band_in_rx_supported(struct iwl_mvm *mvm) 1630 { 1631 return fw_has_api(&mvm->fw->ucode_capa, 1632 IWL_UCODE_TLV_API_BAND_IN_RX_DATA); 1633 } 1634 1635 static inline bool iwl_mvm_has_new_rx_stats_api(struct iwl_mvm *mvm) 1636 { 1637 return fw_has_api(&mvm->fw->ucode_capa, 1638 IWL_UCODE_TLV_API_NEW_RX_STATS); 1639 } 1640 1641 static inline bool iwl_mvm_has_quota_low_latency(struct iwl_mvm *mvm) 1642 { 1643 return fw_has_api(&mvm->fw->ucode_capa, 1644 IWL_UCODE_TLV_API_QUOTA_LOW_LATENCY); 1645 } 1646 1647 static inline bool iwl_mvm_has_no_host_disable_tx(struct iwl_mvm *mvm) 1648 { 1649 return fw_has_api(&mvm->fw->ucode_capa, 1650 IWL_UCODE_TLV_API_NO_HOST_DISABLE_TX); 1651 } 1652 1653 static inline bool iwl_mvm_has_tlc_offload(const struct iwl_mvm *mvm) 1654 { 1655 return fw_has_capa(&mvm->fw->ucode_capa, 1656 IWL_UCODE_TLV_CAPA_TLC_OFFLOAD); 1657 } 1658 1659 static inline struct agg_tx_status * 1660 iwl_mvm_get_agg_status(struct iwl_mvm *mvm, void *tx_resp) 1661 { 1662 if (iwl_mvm_has_new_tx_api(mvm)) 1663 return &((struct iwl_mvm_tx_resp *)tx_resp)->status; 1664 else 1665 return ((struct iwl_mvm_tx_resp_v3 *)tx_resp)->status; 1666 } 1667 1668 static inline bool iwl_mvm_is_tt_in_fw(struct iwl_mvm *mvm) 1669 { 1670 /* these two TLV are redundant since the responsibility to CT-kill by 1671 * FW happens only after we send at least one command of 1672 * temperature THs report. 1673 */ 1674 return fw_has_capa(&mvm->fw->ucode_capa, 1675 IWL_UCODE_TLV_CAPA_CT_KILL_BY_FW) && 1676 fw_has_capa(&mvm->fw->ucode_capa, 1677 IWL_UCODE_TLV_CAPA_TEMP_THS_REPORT_SUPPORT); 1678 } 1679 1680 static inline bool iwl_mvm_is_ctdp_supported(struct iwl_mvm *mvm) 1681 { 1682 return fw_has_capa(&mvm->fw->ucode_capa, 1683 IWL_UCODE_TLV_CAPA_CTDP_SUPPORT); 1684 } 1685 1686 static inline bool iwl_mvm_is_esr_supported(struct iwl_trans *trans) 1687 { 1688 if ((CSR_HW_RFID_TYPE(trans->hw_rf_id) == IWL_CFG_RF_TYPE_FM) && 1689 !CSR_HW_RFID_IS_CDB(trans->hw_rf_id)) 1690 /* Step A doesn't support eSR */ 1691 return CSR_HW_RFID_STEP(trans->hw_rf_id); 1692 1693 return false; 1694 } 1695 1696 static inline int iwl_mvm_max_active_links(struct iwl_mvm *mvm, 1697 struct ieee80211_vif *vif) 1698 { 1699 struct iwl_trans *trans = mvm->fwrt.trans; 1700 1701 if (vif->type == NL80211_IFTYPE_AP) 1702 return mvm->fw->ucode_capa.num_beacons; 1703 1704 /* Check if HW supports eSR or STR */ 1705 if (iwl_mvm_is_esr_supported(trans) || 1706 (CSR_HW_RFID_TYPE(trans->hw_rf_id) == IWL_CFG_RF_TYPE_FM && 1707 CSR_HW_RFID_IS_CDB(trans->hw_rf_id))) 1708 return IWL_MVM_FW_MAX_ACTIVE_LINKS_NUM; 1709 1710 return 1; 1711 } 1712 1713 extern const u8 iwl_mvm_ac_to_tx_fifo[]; 1714 extern const u8 iwl_mvm_ac_to_gen2_tx_fifo[]; 1715 extern const u8 iwl_mvm_ac_to_bz_tx_fifo[]; 1716 1717 static inline u8 iwl_mvm_mac_ac_to_tx_fifo(struct iwl_mvm *mvm, 1718 enum ieee80211_ac_numbers ac) 1719 { 1720 if (mvm->trans->trans_cfg->device_family >= IWL_DEVICE_FAMILY_BZ) 1721 return iwl_mvm_ac_to_bz_tx_fifo[ac]; 1722 if (iwl_mvm_has_new_tx_api(mvm)) 1723 return iwl_mvm_ac_to_gen2_tx_fifo[ac]; 1724 return iwl_mvm_ac_to_tx_fifo[ac]; 1725 } 1726 1727 struct iwl_rate_info { 1728 u8 plcp; /* uCode API: IWL_RATE_6M_PLCP, etc. */ 1729 u8 plcp_siso; /* uCode API: IWL_RATE_SISO_6M_PLCP, etc. */ 1730 u8 plcp_mimo2; /* uCode API: IWL_RATE_MIMO2_6M_PLCP, etc. */ 1731 u8 plcp_mimo3; /* uCode API: IWL_RATE_MIMO3_6M_PLCP, etc. */ 1732 u8 ieee; /* MAC header: IWL_RATE_6M_IEEE, etc. */ 1733 }; 1734 1735 void __iwl_mvm_mac_stop(struct iwl_mvm *mvm); 1736 int __iwl_mvm_mac_start(struct iwl_mvm *mvm); 1737 1738 /****************** 1739 * MVM Methods 1740 ******************/ 1741 /* uCode */ 1742 int iwl_run_init_mvm_ucode(struct iwl_mvm *mvm); 1743 1744 /* Utils */ 1745 int iwl_mvm_legacy_hw_idx_to_mac80211_idx(u32 rate_n_flags, 1746 enum nl80211_band band); 1747 int iwl_mvm_legacy_rate_to_mac80211_idx(u32 rate_n_flags, 1748 enum nl80211_band band); 1749 void iwl_mvm_hwrate_to_tx_rate(u32 rate_n_flags, 1750 enum nl80211_band band, 1751 struct ieee80211_tx_rate *r); 1752 void iwl_mvm_hwrate_to_tx_rate_v1(u32 rate_n_flags, 1753 enum nl80211_band band, 1754 struct ieee80211_tx_rate *r); 1755 u8 iwl_mvm_mac80211_idx_to_hwrate(const struct iwl_fw *fw, int rate_idx); 1756 u8 iwl_mvm_mac80211_ac_to_ucode_ac(enum ieee80211_ac_numbers ac); 1757 bool iwl_mvm_is_nic_ack_enabled(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1758 1759 static inline void iwl_mvm_dump_nic_error_log(struct iwl_mvm *mvm) 1760 { 1761 iwl_fwrt_dump_error_logs(&mvm->fwrt); 1762 } 1763 1764 u8 first_antenna(u8 mask); 1765 u8 iwl_mvm_next_antenna(struct iwl_mvm *mvm, u8 valid, u8 last_idx); 1766 void iwl_mvm_get_sync_time(struct iwl_mvm *mvm, int clock_type, u32 *gp2, 1767 u64 *boottime, ktime_t *realtime); 1768 u32 iwl_mvm_get_systime(struct iwl_mvm *mvm); 1769 u32 iwl_mvm_find_ie_offset(u8 *beacon, u8 eid, u32 frame_size); 1770 1771 /* Tx / Host Commands */ 1772 int __must_check iwl_mvm_send_cmd(struct iwl_mvm *mvm, 1773 struct iwl_host_cmd *cmd); 1774 int __must_check iwl_mvm_send_cmd_pdu(struct iwl_mvm *mvm, u32 id, 1775 u32 flags, u16 len, const void *data); 1776 int __must_check iwl_mvm_send_cmd_status(struct iwl_mvm *mvm, 1777 struct iwl_host_cmd *cmd, 1778 u32 *status); 1779 int __must_check iwl_mvm_send_cmd_pdu_status(struct iwl_mvm *mvm, u32 id, 1780 u16 len, const void *data, 1781 u32 *status); 1782 int iwl_mvm_tx_skb_sta(struct iwl_mvm *mvm, struct sk_buff *skb, 1783 struct ieee80211_sta *sta); 1784 int iwl_mvm_tx_skb_non_sta(struct iwl_mvm *mvm, struct sk_buff *skb); 1785 void iwl_mvm_set_tx_cmd(struct iwl_mvm *mvm, struct sk_buff *skb, 1786 struct iwl_tx_cmd *tx_cmd, 1787 struct ieee80211_tx_info *info, u8 sta_id); 1788 void iwl_mvm_set_tx_cmd_rate(struct iwl_mvm *mvm, struct iwl_tx_cmd *tx_cmd, 1789 struct ieee80211_tx_info *info, 1790 struct ieee80211_sta *sta, __le16 fc); 1791 void iwl_mvm_mac_itxq_xmit(struct ieee80211_hw *hw, struct ieee80211_txq *txq); 1792 unsigned int iwl_mvm_max_amsdu_size(struct iwl_mvm *mvm, 1793 struct ieee80211_sta *sta, 1794 unsigned int tid); 1795 1796 #ifdef CONFIG_IWLWIFI_DEBUG 1797 const char *iwl_mvm_get_tx_fail_reason(u32 status); 1798 #else 1799 static inline const char *iwl_mvm_get_tx_fail_reason(u32 status) { return ""; } 1800 #endif 1801 int iwl_mvm_flush_tx_path(struct iwl_mvm *mvm, u32 tfd_msk); 1802 int iwl_mvm_flush_sta(struct iwl_mvm *mvm, u32 sta_id, u32 tfd_queue_mask); 1803 int iwl_mvm_flush_sta_tids(struct iwl_mvm *mvm, u32 sta_id, u16 tids); 1804 1805 /* Utils to extract sta related data */ 1806 __le32 iwl_mvm_get_sta_htc_flags(struct ieee80211_sta *sta, 1807 struct ieee80211_link_sta *link_sta); 1808 u8 iwl_mvm_get_sta_uapsd_acs(struct ieee80211_sta *sta); 1809 u32 iwl_mvm_get_sta_ampdu_dens(struct ieee80211_link_sta *link_sta, 1810 struct ieee80211_bss_conf *link_conf, 1811 u32 *_agg_size); 1812 int iwl_mvm_set_sta_pkt_ext(struct iwl_mvm *mvm, 1813 struct ieee80211_link_sta *link_sta, 1814 struct iwl_he_pkt_ext_v2 *pkt_ext); 1815 1816 void iwl_mvm_async_handlers_purge(struct iwl_mvm *mvm); 1817 1818 static inline void iwl_mvm_set_tx_cmd_ccmp(struct ieee80211_tx_info *info, 1819 struct iwl_tx_cmd *tx_cmd) 1820 { 1821 struct ieee80211_key_conf *keyconf = info->control.hw_key; 1822 1823 tx_cmd->sec_ctl = TX_CMD_SEC_CCM; 1824 memcpy(tx_cmd->key, keyconf->key, keyconf->keylen); 1825 } 1826 1827 static inline void iwl_mvm_wait_for_async_handlers(struct iwl_mvm *mvm) 1828 { 1829 flush_work(&mvm->async_handlers_wk); 1830 } 1831 1832 /* Statistics */ 1833 void iwl_mvm_handle_rx_system_oper_stats(struct iwl_mvm *mvm, 1834 struct iwl_rx_cmd_buffer *rxb); 1835 void iwl_mvm_handle_rx_system_oper_part1_stats(struct iwl_mvm *mvm, 1836 struct iwl_rx_cmd_buffer *rxb); 1837 static inline void 1838 iwl_mvm_handle_rx_system_end_stats_notif(struct iwl_mvm *mvm, 1839 struct iwl_rx_cmd_buffer *rxb) 1840 { 1841 } 1842 1843 void iwl_mvm_handle_rx_statistics(struct iwl_mvm *mvm, 1844 struct iwl_rx_packet *pkt); 1845 void iwl_mvm_rx_statistics(struct iwl_mvm *mvm, 1846 struct iwl_rx_cmd_buffer *rxb); 1847 int iwl_mvm_request_statistics(struct iwl_mvm *mvm, bool clear); 1848 int iwl_mvm_request_periodic_system_statistics(struct iwl_mvm *mvm, 1849 bool enable); 1850 void iwl_mvm_accu_radio_stats(struct iwl_mvm *mvm); 1851 1852 /* NVM */ 1853 int iwl_nvm_init(struct iwl_mvm *mvm); 1854 int iwl_mvm_load_nvm_to_nic(struct iwl_mvm *mvm); 1855 1856 static inline u8 iwl_mvm_get_valid_tx_ant(struct iwl_mvm *mvm) 1857 { 1858 u8 tx_ant = mvm->fw->valid_tx_ant; 1859 1860 if (mvm->nvm_data && mvm->nvm_data->valid_tx_ant) 1861 tx_ant &= mvm->nvm_data->valid_tx_ant; 1862 1863 if (mvm->set_tx_ant) 1864 tx_ant &= mvm->set_tx_ant; 1865 1866 return tx_ant; 1867 } 1868 1869 static inline u8 iwl_mvm_get_valid_rx_ant(struct iwl_mvm *mvm) 1870 { 1871 u8 rx_ant = mvm->fw->valid_tx_ant; 1872 1873 if (mvm->nvm_data && mvm->nvm_data->valid_rx_ant) 1874 rx_ant &= mvm->nvm_data->valid_tx_ant; 1875 1876 if (mvm->set_rx_ant) 1877 rx_ant &= mvm->set_rx_ant; 1878 1879 return rx_ant; 1880 1881 } 1882 1883 static inline void iwl_mvm_toggle_tx_ant(struct iwl_mvm *mvm, u8 *ant) 1884 { 1885 *ant = iwl_mvm_next_antenna(mvm, iwl_mvm_get_valid_tx_ant(mvm), *ant); 1886 } 1887 1888 static inline u32 iwl_mvm_get_phy_config(struct iwl_mvm *mvm) 1889 { 1890 u32 phy_config = ~(FW_PHY_CFG_TX_CHAIN | 1891 FW_PHY_CFG_RX_CHAIN); 1892 u32 valid_rx_ant = iwl_mvm_get_valid_rx_ant(mvm); 1893 u32 valid_tx_ant = iwl_mvm_get_valid_tx_ant(mvm); 1894 1895 phy_config |= valid_tx_ant << FW_PHY_CFG_TX_CHAIN_POS | 1896 valid_rx_ant << FW_PHY_CFG_RX_CHAIN_POS; 1897 1898 return mvm->fw->phy_config & phy_config; 1899 } 1900 1901 int iwl_mvm_up(struct iwl_mvm *mvm); 1902 int iwl_mvm_load_d3_fw(struct iwl_mvm *mvm); 1903 1904 int iwl_mvm_mac_setup_register(struct iwl_mvm *mvm); 1905 1906 void iwl_mvm_mac_init_mvmvif(struct iwl_mvm *mvm, struct iwl_mvm_vif *mvmvif); 1907 1908 /* 1909 * FW notifications / CMD responses handlers 1910 * Convention: iwl_mvm_rx_<NAME OF THE CMD> 1911 */ 1912 void iwl_mvm_rx_mq(struct iwl_op_mode *op_mode, 1913 struct napi_struct *napi, 1914 struct iwl_rx_cmd_buffer *rxb); 1915 void iwl_mvm_rx_rx_phy_cmd(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb); 1916 void iwl_mvm_rx_rx_mpdu(struct iwl_mvm *mvm, struct napi_struct *napi, 1917 struct iwl_rx_cmd_buffer *rxb); 1918 void iwl_mvm_rx_mpdu_mq(struct iwl_mvm *mvm, struct napi_struct *napi, 1919 struct iwl_rx_cmd_buffer *rxb, int queue); 1920 void iwl_mvm_rx_monitor_no_data(struct iwl_mvm *mvm, struct napi_struct *napi, 1921 struct iwl_rx_cmd_buffer *rxb, int queue); 1922 void iwl_mvm_rx_frame_release(struct iwl_mvm *mvm, struct napi_struct *napi, 1923 struct iwl_rx_cmd_buffer *rxb, int queue); 1924 void iwl_mvm_rx_bar_frame_release(struct iwl_mvm *mvm, struct napi_struct *napi, 1925 struct iwl_rx_cmd_buffer *rxb, int queue); 1926 void iwl_mvm_rx_queue_notif(struct iwl_mvm *mvm, struct napi_struct *napi, 1927 struct iwl_rx_cmd_buffer *rxb, int queue); 1928 void iwl_mvm_rx_tx_cmd(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb); 1929 void iwl_mvm_mfu_assert_dump_notif(struct iwl_mvm *mvm, 1930 struct iwl_rx_cmd_buffer *rxb); 1931 void iwl_mvm_send_recovery_cmd(struct iwl_mvm *mvm, u32 flags); 1932 void iwl_mvm_rx_ba_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb); 1933 void iwl_mvm_rx_ant_coupling_notif(struct iwl_mvm *mvm, 1934 struct iwl_rx_cmd_buffer *rxb); 1935 void iwl_mvm_rx_fw_error(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb); 1936 void iwl_mvm_rx_mfuart_notif(struct iwl_mvm *mvm, 1937 struct iwl_rx_cmd_buffer *rxb); 1938 void iwl_mvm_rx_shared_mem_cfg_notif(struct iwl_mvm *mvm, 1939 struct iwl_rx_cmd_buffer *rxb); 1940 1941 /* MVM PHY */ 1942 struct iwl_mvm_phy_ctxt *iwl_mvm_get_free_phy_ctxt(struct iwl_mvm *mvm); 1943 int iwl_mvm_phy_ctxt_add(struct iwl_mvm *mvm, struct iwl_mvm_phy_ctxt *ctxt, 1944 const struct cfg80211_chan_def *chandef, 1945 const struct cfg80211_chan_def *ap, 1946 u8 chains_static, u8 chains_dynamic); 1947 int iwl_mvm_phy_ctxt_changed(struct iwl_mvm *mvm, struct iwl_mvm_phy_ctxt *ctxt, 1948 const struct cfg80211_chan_def *chandef, 1949 const struct cfg80211_chan_def *ap, 1950 u8 chains_static, u8 chains_dynamic); 1951 void iwl_mvm_phy_ctxt_ref(struct iwl_mvm *mvm, 1952 struct iwl_mvm_phy_ctxt *ctxt); 1953 void iwl_mvm_phy_ctxt_unref(struct iwl_mvm *mvm, 1954 struct iwl_mvm_phy_ctxt *ctxt); 1955 int iwl_mvm_phy_ctx_count(struct iwl_mvm *mvm); 1956 u8 iwl_mvm_get_channel_width(const struct cfg80211_chan_def *chandef); 1957 u8 iwl_mvm_get_ctrl_pos(const struct cfg80211_chan_def *chandef); 1958 int iwl_mvm_phy_send_rlc(struct iwl_mvm *mvm, struct iwl_mvm_phy_ctxt *ctxt, 1959 u8 chains_static, u8 chains_dynamic); 1960 1961 /* MAC (virtual interface) programming */ 1962 1963 void iwl_mvm_prepare_mac_removal(struct iwl_mvm *mvm, 1964 struct ieee80211_vif *vif); 1965 void iwl_mvm_set_fw_basic_rates(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1966 struct ieee80211_bss_conf *link_conf, 1967 __le32 *cck_rates, __le32 *ofdm_rates); 1968 void iwl_mvm_set_fw_protection_flags(struct iwl_mvm *mvm, 1969 struct ieee80211_vif *vif, 1970 struct ieee80211_bss_conf *link_conf, 1971 __le32 *protection_flags, u32 ht_flag, 1972 u32 tgg_flag); 1973 void iwl_mvm_set_fw_qos_params(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1974 struct ieee80211_bss_conf *link_conf, 1975 struct iwl_ac_qos *ac, __le32 *qos_flags); 1976 bool iwl_mvm_set_fw_mu_edca_params(struct iwl_mvm *mvm, 1977 const struct iwl_mvm_vif_link_info *link_info, 1978 struct iwl_he_backoff_conf *trig_based_txf); 1979 void iwl_mvm_set_fw_dtim_tbtt(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1980 struct ieee80211_bss_conf *link_conf, 1981 __le64 *dtim_tsf, __le32 *dtim_time, 1982 __le32 *assoc_beacon_arrive_time); 1983 __le32 iwl_mac_ctxt_p2p_dev_has_extended_disc(struct iwl_mvm *mvm, 1984 struct ieee80211_vif *vif); 1985 void iwl_mvm_mac_ctxt_cmd_ap_set_filter_flags(struct iwl_mvm *mvm, 1986 struct iwl_mvm_vif *mvmvif, 1987 __le32 *filter_flags, 1988 int accept_probe_req_flag, 1989 int accept_beacon_flag); 1990 int iwl_mvm_get_mac_type(struct ieee80211_vif *vif); 1991 __le32 iwl_mvm_mac_ctxt_cmd_p2p_sta_get_oppps_ctwin(struct iwl_mvm *mvm, 1992 struct ieee80211_vif *vif); 1993 u32 iwl_mvm_mac_ctxt_cmd_sta_get_twt_policy(struct iwl_mvm *mvm, 1994 struct ieee80211_vif *vif); 1995 int iwl_mvm_mld_mac_ctxt_add(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1996 int iwl_mvm_mld_mac_ctxt_changed(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1997 bool force_assoc_off); 1998 int iwl_mvm_mld_mac_ctxt_remove(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 1999 int iwl_mvm_mac_ctxt_init(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2000 int iwl_mvm_mac_ctxt_add(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2001 int iwl_mvm_mac_ctxt_changed(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2002 bool force_assoc_off, const u8 *bssid_override); 2003 int iwl_mvm_mac_ctxt_remove(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2004 int iwl_mvm_mac_ctxt_beacon_changed(struct iwl_mvm *mvm, 2005 struct ieee80211_vif *vif, 2006 struct ieee80211_bss_conf *link_conf); 2007 int iwl_mvm_mac_ctxt_send_beacon_cmd(struct iwl_mvm *mvm, 2008 struct sk_buff *beacon, 2009 void *data, int len); 2010 u8 iwl_mvm_mac_ctxt_get_beacon_rate(struct iwl_mvm *mvm, 2011 struct ieee80211_tx_info *info, 2012 struct ieee80211_vif *vif); 2013 u8 iwl_mvm_mac_ctxt_get_lowest_rate(struct iwl_mvm *mvm, 2014 struct ieee80211_tx_info *info, 2015 struct ieee80211_vif *vif); 2016 u16 iwl_mvm_mac_ctxt_get_beacon_flags(const struct iwl_fw *fw, 2017 u8 rate_idx); 2018 void iwl_mvm_mac_ctxt_set_tim(struct iwl_mvm *mvm, 2019 __le32 *tim_index, __le32 *tim_size, 2020 u8 *beacon, u32 frame_size); 2021 void iwl_mvm_rx_beacon_notif(struct iwl_mvm *mvm, 2022 struct iwl_rx_cmd_buffer *rxb); 2023 void iwl_mvm_rx_missed_beacons_notif(struct iwl_mvm *mvm, 2024 struct iwl_rx_cmd_buffer *rxb); 2025 void iwl_mvm_rx_stored_beacon_notif(struct iwl_mvm *mvm, 2026 struct iwl_rx_cmd_buffer *rxb); 2027 void iwl_mvm_mu_mimo_grp_notif(struct iwl_mvm *mvm, 2028 struct iwl_rx_cmd_buffer *rxb); 2029 void iwl_mvm_sta_pm_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb); 2030 void iwl_mvm_window_status_notif(struct iwl_mvm *mvm, 2031 struct iwl_rx_cmd_buffer *rxb); 2032 void iwl_mvm_mac_ctxt_recalc_tsf_id(struct iwl_mvm *mvm, 2033 struct ieee80211_vif *vif); 2034 void iwl_mvm_probe_resp_data_notif(struct iwl_mvm *mvm, 2035 struct iwl_rx_cmd_buffer *rxb); 2036 void iwl_mvm_rx_missed_vap_notif(struct iwl_mvm *mvm, 2037 struct iwl_rx_cmd_buffer *rxb); 2038 void iwl_mvm_channel_switch_start_notif(struct iwl_mvm *mvm, 2039 struct iwl_rx_cmd_buffer *rxb); 2040 void iwl_mvm_channel_switch_error_notif(struct iwl_mvm *mvm, 2041 struct iwl_rx_cmd_buffer *rxb); 2042 /* Bindings */ 2043 int iwl_mvm_binding_add_vif(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2044 int iwl_mvm_binding_remove_vif(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2045 u32 iwl_mvm_get_lmac_id(struct iwl_mvm *mvm, enum nl80211_band band); 2046 2047 /* Links */ 2048 int iwl_mvm_set_link_mapping(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2049 struct ieee80211_bss_conf *link_conf); 2050 int iwl_mvm_add_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2051 struct ieee80211_bss_conf *link_conf); 2052 int iwl_mvm_link_changed(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2053 struct ieee80211_bss_conf *link_conf, 2054 u32 changes, bool active); 2055 int iwl_mvm_unset_link_mapping(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2056 struct ieee80211_bss_conf *link_conf); 2057 int iwl_mvm_remove_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2058 struct ieee80211_bss_conf *link_conf); 2059 int iwl_mvm_disable_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2060 struct ieee80211_bss_conf *link_conf); 2061 2062 void iwl_mvm_select_links(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2063 u8 iwl_mvm_get_primary_link(struct ieee80211_vif *vif); 2064 u8 iwl_mvm_get_other_link(struct ieee80211_vif *vif, u8 link_id); 2065 2066 struct iwl_mvm_link_sel_data { 2067 u8 link_id; 2068 const struct cfg80211_chan_def *chandef; 2069 s32 signal; 2070 u16 grade; 2071 }; 2072 2073 #if IS_ENABLED(CONFIG_IWLWIFI_KUNIT_TESTS) 2074 unsigned int iwl_mvm_get_link_grade(struct ieee80211_bss_conf *link_conf); 2075 bool iwl_mvm_mld_valid_link_pair(struct ieee80211_vif *vif, 2076 const struct iwl_mvm_link_sel_data *a, 2077 const struct iwl_mvm_link_sel_data *b); 2078 2079 s8 iwl_mvm_average_dbm_values(const struct iwl_umac_scan_channel_survey_notif *notif); 2080 #endif 2081 2082 /* AP and IBSS */ 2083 bool iwl_mvm_start_ap_ibss_common(struct ieee80211_hw *hw, 2084 struct ieee80211_vif *vif, int *ret); 2085 void iwl_mvm_stop_ap_ibss_common(struct iwl_mvm *mvm, 2086 struct ieee80211_vif *vif); 2087 2088 /* BSS Info */ 2089 void iwl_mvm_bss_info_changed_station_common(struct iwl_mvm *mvm, 2090 struct ieee80211_vif *vif, 2091 struct ieee80211_bss_conf *link_conf, 2092 u64 changes); 2093 void iwl_mvm_bss_info_changed_station_assoc(struct iwl_mvm *mvm, 2094 struct ieee80211_vif *vif, 2095 u64 changes); 2096 2097 /* ROC */ 2098 /** 2099 * struct iwl_mvm_roc_ops - callbacks for the remain_on_channel() 2100 * 2101 * Since the only difference between both MLD and 2102 * non-MLD versions of remain_on_channel() is these function calls, 2103 * each version will send its specific function calls to 2104 * %iwl_mvm_roc_common(). 2105 * 2106 * @add_aux_sta_for_hs20: pointer to the function that adds an aux sta 2107 * for Hot Spot 2.0 2108 * @link: For a P2P Device interface, pointer to a function that links the 2109 * MAC/Link to the PHY context 2110 */ 2111 struct iwl_mvm_roc_ops { 2112 int (*add_aux_sta_for_hs20)(struct iwl_mvm *mvm, u32 lmac_id); 2113 int (*link)(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2114 }; 2115 2116 int iwl_mvm_roc_common(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 2117 struct ieee80211_channel *channel, int duration, 2118 enum ieee80211_roc_type type, 2119 const struct iwl_mvm_roc_ops *ops); 2120 int iwl_mvm_cancel_roc(struct ieee80211_hw *hw, 2121 struct ieee80211_vif *vif); 2122 /*Session Protection */ 2123 void iwl_mvm_protect_assoc(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2124 u32 duration_override, unsigned int link_id); 2125 2126 /* Quota management */ 2127 static inline size_t iwl_mvm_quota_cmd_size(struct iwl_mvm *mvm) 2128 { 2129 return iwl_mvm_has_quota_low_latency(mvm) ? 2130 sizeof(struct iwl_time_quota_cmd) : 2131 sizeof(struct iwl_time_quota_cmd_v1); 2132 } 2133 2134 static inline struct iwl_time_quota_data 2135 *iwl_mvm_quota_cmd_get_quota(struct iwl_mvm *mvm, 2136 struct iwl_time_quota_cmd *cmd, 2137 int i) 2138 { 2139 struct iwl_time_quota_data_v1 *quotas; 2140 2141 if (iwl_mvm_has_quota_low_latency(mvm)) 2142 return &cmd->quotas[i]; 2143 2144 quotas = (struct iwl_time_quota_data_v1 *)cmd->quotas; 2145 return (struct iwl_time_quota_data *)"as[i]; 2146 } 2147 2148 int iwl_mvm_update_quotas(struct iwl_mvm *mvm, bool force_upload, 2149 struct ieee80211_vif *disabled_vif); 2150 2151 /* Scanning */ 2152 int iwl_mvm_reg_scan_start(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2153 struct cfg80211_scan_request *req, 2154 struct ieee80211_scan_ies *ies); 2155 size_t iwl_mvm_scan_size(struct iwl_mvm *mvm); 2156 int iwl_mvm_scan_stop(struct iwl_mvm *mvm, int type, bool notify); 2157 2158 int iwl_mvm_max_scan_ie_len(struct iwl_mvm *mvm); 2159 void iwl_mvm_report_scan_aborted(struct iwl_mvm *mvm); 2160 void iwl_mvm_scan_timeout_wk(struct work_struct *work); 2161 int iwl_mvm_int_mlo_scan(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2162 void iwl_mvm_rx_channel_survey_notif(struct iwl_mvm *mvm, 2163 struct iwl_rx_cmd_buffer *rxb); 2164 2165 /* Scheduled scan */ 2166 void iwl_mvm_rx_lmac_scan_complete_notif(struct iwl_mvm *mvm, 2167 struct iwl_rx_cmd_buffer *rxb); 2168 void iwl_mvm_rx_lmac_scan_iter_complete_notif(struct iwl_mvm *mvm, 2169 struct iwl_rx_cmd_buffer *rxb); 2170 int iwl_mvm_sched_scan_start(struct iwl_mvm *mvm, 2171 struct ieee80211_vif *vif, 2172 struct cfg80211_sched_scan_request *req, 2173 struct ieee80211_scan_ies *ies, 2174 int type); 2175 void iwl_mvm_rx_scan_match_found(struct iwl_mvm *mvm, 2176 struct iwl_rx_cmd_buffer *rxb); 2177 2178 /* UMAC scan */ 2179 int iwl_mvm_config_scan(struct iwl_mvm *mvm); 2180 void iwl_mvm_rx_umac_scan_complete_notif(struct iwl_mvm *mvm, 2181 struct iwl_rx_cmd_buffer *rxb); 2182 void iwl_mvm_rx_umac_scan_iter_complete_notif(struct iwl_mvm *mvm, 2183 struct iwl_rx_cmd_buffer *rxb); 2184 2185 /* MVM debugfs */ 2186 #ifdef CONFIG_IWLWIFI_DEBUGFS 2187 void iwl_mvm_dbgfs_register(struct iwl_mvm *mvm); 2188 void iwl_mvm_vif_add_debugfs(struct ieee80211_hw *hw, struct ieee80211_vif *vif); 2189 void iwl_mvm_vif_dbgfs_add_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2190 void iwl_mvm_vif_dbgfs_rm_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2191 #else 2192 static inline void iwl_mvm_dbgfs_register(struct iwl_mvm *mvm) 2193 { 2194 } 2195 static inline void 2196 iwl_mvm_vif_dbgfs_add_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif) 2197 { 2198 } 2199 static inline void 2200 iwl_mvm_vif_dbgfs_rm_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif) 2201 { 2202 } 2203 #endif /* CONFIG_IWLWIFI_DEBUGFS */ 2204 2205 /* rate scaling */ 2206 int iwl_mvm_send_lq_cmd(struct iwl_mvm *mvm, struct iwl_lq_cmd *lq); 2207 void iwl_mvm_update_frame_stats(struct iwl_mvm *mvm, u32 rate, bool agg); 2208 int rs_pretty_print_rate_v1(char *buf, int bufsz, const u32 rate); 2209 void rs_update_last_rssi(struct iwl_mvm *mvm, 2210 struct iwl_mvm_sta *mvmsta, 2211 struct ieee80211_rx_status *rx_status); 2212 2213 /* power management */ 2214 int iwl_mvm_power_update_device(struct iwl_mvm *mvm); 2215 int iwl_mvm_power_update_mac(struct iwl_mvm *mvm); 2216 int iwl_mvm_power_update_ps(struct iwl_mvm *mvm); 2217 int iwl_mvm_power_mac_dbgfs_read(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2218 char *buf, int bufsz); 2219 2220 void iwl_mvm_power_vif_assoc(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2221 void iwl_mvm_power_uapsd_misbehaving_ap_notif(struct iwl_mvm *mvm, 2222 struct iwl_rx_cmd_buffer *rxb); 2223 2224 #ifdef CONFIG_IWLWIFI_LEDS 2225 int iwl_mvm_leds_init(struct iwl_mvm *mvm); 2226 void iwl_mvm_leds_exit(struct iwl_mvm *mvm); 2227 void iwl_mvm_leds_sync(struct iwl_mvm *mvm); 2228 #else 2229 static inline int iwl_mvm_leds_init(struct iwl_mvm *mvm) 2230 { 2231 return 0; 2232 } 2233 static inline void iwl_mvm_leds_exit(struct iwl_mvm *mvm) 2234 { 2235 } 2236 static inline void iwl_mvm_leds_sync(struct iwl_mvm *mvm) 2237 { 2238 } 2239 #endif 2240 2241 /* D3 (WoWLAN, NetDetect) */ 2242 int iwl_mvm_suspend(struct ieee80211_hw *hw, struct cfg80211_wowlan *wowlan); 2243 int iwl_mvm_resume(struct ieee80211_hw *hw); 2244 void iwl_mvm_set_wakeup(struct ieee80211_hw *hw, bool enabled); 2245 void iwl_mvm_set_rekey_data(struct ieee80211_hw *hw, 2246 struct ieee80211_vif *vif, 2247 struct cfg80211_gtk_rekey_data *data); 2248 void iwl_mvm_ipv6_addr_change(struct ieee80211_hw *hw, 2249 struct ieee80211_vif *vif, 2250 struct inet6_dev *idev); 2251 void iwl_mvm_set_default_unicast_key(struct ieee80211_hw *hw, 2252 struct ieee80211_vif *vif, int idx); 2253 extern const struct file_operations iwl_dbgfs_d3_test_ops; 2254 #ifdef CONFIG_PM 2255 void iwl_mvm_set_last_nonqos_seq(struct iwl_mvm *mvm, 2256 struct ieee80211_vif *vif); 2257 #else 2258 static inline void 2259 iwl_mvm_set_last_nonqos_seq(struct iwl_mvm *mvm, struct ieee80211_vif *vif) 2260 { 2261 } 2262 #endif 2263 void iwl_mvm_set_wowlan_qos_seq(struct iwl_mvm_sta *mvm_ap_sta, 2264 struct iwl_wowlan_config_cmd *cmd); 2265 int iwl_mvm_send_proto_offload(struct iwl_mvm *mvm, 2266 struct ieee80211_vif *vif, 2267 bool disable_offloading, 2268 bool offload_ns, 2269 u32 cmd_flags, 2270 u8 sta_id); 2271 2272 /* BT Coex */ 2273 int iwl_mvm_send_bt_init_conf(struct iwl_mvm *mvm); 2274 void iwl_mvm_rx_bt_coex_notif(struct iwl_mvm *mvm, 2275 struct iwl_rx_cmd_buffer *rxb); 2276 void iwl_mvm_bt_rssi_event(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2277 enum ieee80211_rssi_event_data); 2278 void iwl_mvm_bt_coex_vif_change(struct iwl_mvm *mvm); 2279 u16 iwl_mvm_coex_agg_time_limit(struct iwl_mvm *mvm, 2280 struct ieee80211_sta *sta); 2281 bool iwl_mvm_bt_coex_is_mimo_allowed(struct iwl_mvm *mvm, 2282 struct ieee80211_sta *sta); 2283 bool iwl_mvm_bt_coex_is_ant_avail(struct iwl_mvm *mvm, u8 ant); 2284 bool iwl_mvm_bt_coex_is_shared_ant_avail(struct iwl_mvm *mvm); 2285 bool iwl_mvm_bt_coex_is_tpc_allowed(struct iwl_mvm *mvm, 2286 enum nl80211_band band); 2287 u8 iwl_mvm_bt_coex_get_single_ant_msk(struct iwl_mvm *mvm, u8 enabled_ants); 2288 u8 iwl_mvm_bt_coex_tx_prio(struct iwl_mvm *mvm, struct ieee80211_hdr *hdr, 2289 struct ieee80211_tx_info *info, u8 ac); 2290 2291 /* beacon filtering */ 2292 #ifdef CONFIG_IWLWIFI_DEBUGFS 2293 void 2294 iwl_mvm_beacon_filter_debugfs_parameters(struct ieee80211_vif *vif, 2295 struct iwl_beacon_filter_cmd *cmd); 2296 #else 2297 static inline void 2298 iwl_mvm_beacon_filter_debugfs_parameters(struct ieee80211_vif *vif, 2299 struct iwl_beacon_filter_cmd *cmd) 2300 {} 2301 #endif 2302 int iwl_mvm_enable_beacon_filter(struct iwl_mvm *mvm, 2303 struct ieee80211_vif *vif); 2304 int iwl_mvm_disable_beacon_filter(struct iwl_mvm *mvm, 2305 struct ieee80211_vif *vif); 2306 /* SMPS */ 2307 void iwl_mvm_update_smps(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2308 enum iwl_mvm_smps_type_request req_type, 2309 enum ieee80211_smps_mode smps_request, 2310 unsigned int link_id); 2311 void 2312 iwl_mvm_update_smps_on_active_links(struct iwl_mvm *mvm, 2313 struct ieee80211_vif *vif, 2314 enum iwl_mvm_smps_type_request req_type, 2315 enum ieee80211_smps_mode smps_request); 2316 bool iwl_mvm_rx_diversity_allowed(struct iwl_mvm *mvm, 2317 struct iwl_mvm_phy_ctxt *ctxt); 2318 void iwl_mvm_update_link_smps(struct ieee80211_vif *vif, 2319 struct ieee80211_bss_conf *link_conf); 2320 2321 /* Low latency */ 2322 int iwl_mvm_update_low_latency(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2323 bool low_latency, 2324 enum iwl_mvm_low_latency_cause cause); 2325 /* get SystemLowLatencyMode - only needed for beacon threshold? */ 2326 bool iwl_mvm_low_latency(struct iwl_mvm *mvm); 2327 bool iwl_mvm_low_latency_band(struct iwl_mvm *mvm, enum nl80211_band band); 2328 void iwl_mvm_send_low_latency_cmd(struct iwl_mvm *mvm, bool low_latency, 2329 u16 mac_id); 2330 2331 /* get VMACLowLatencyMode */ 2332 static inline bool iwl_mvm_vif_low_latency(struct iwl_mvm_vif *mvmvif) 2333 { 2334 /* 2335 * should this consider associated/active/... state? 2336 * 2337 * Normally low-latency should only be active on interfaces 2338 * that are active, but at least with debugfs it can also be 2339 * enabled on interfaces that aren't active. However, when 2340 * interface aren't active then they aren't added into the 2341 * binding, so this has no real impact. For now, just return 2342 * the current desired low-latency state. 2343 */ 2344 return mvmvif->low_latency_actual; 2345 } 2346 2347 static inline 2348 void iwl_mvm_vif_set_low_latency(struct iwl_mvm_vif *mvmvif, bool set, 2349 enum iwl_mvm_low_latency_cause cause) 2350 { 2351 u8 new_state; 2352 2353 if (set) 2354 mvmvif->low_latency |= cause; 2355 else 2356 mvmvif->low_latency &= ~cause; 2357 2358 /* 2359 * if LOW_LATENCY_DEBUGFS_FORCE_ENABLE is enabled no changes are 2360 * allowed to actual mode. 2361 */ 2362 if (mvmvif->low_latency & LOW_LATENCY_DEBUGFS_FORCE_ENABLE && 2363 cause != LOW_LATENCY_DEBUGFS_FORCE_ENABLE) 2364 return; 2365 2366 if (cause == LOW_LATENCY_DEBUGFS_FORCE_ENABLE && set) 2367 /* 2368 * We enter force state 2369 */ 2370 new_state = !!(mvmvif->low_latency & 2371 LOW_LATENCY_DEBUGFS_FORCE); 2372 else 2373 /* 2374 * Check if any other one set low latency 2375 */ 2376 new_state = !!(mvmvif->low_latency & 2377 ~(LOW_LATENCY_DEBUGFS_FORCE_ENABLE | 2378 LOW_LATENCY_DEBUGFS_FORCE)); 2379 2380 mvmvif->low_latency_actual = new_state; 2381 } 2382 2383 /* Return a bitmask with all the hw supported queues, except for the 2384 * command queue, which can't be flushed. 2385 */ 2386 static inline u32 iwl_mvm_flushable_queues(struct iwl_mvm *mvm) 2387 { 2388 return ((BIT(mvm->trans->trans_cfg->base_params->num_of_queues) - 1) & 2389 ~BIT(IWL_MVM_DQA_CMD_QUEUE)); 2390 } 2391 2392 void iwl_mvm_stop_device(struct iwl_mvm *mvm); 2393 2394 /* Thermal management and CT-kill */ 2395 void iwl_mvm_tt_tx_backoff(struct iwl_mvm *mvm, u32 backoff); 2396 void iwl_mvm_temp_notif(struct iwl_mvm *mvm, 2397 struct iwl_rx_cmd_buffer *rxb); 2398 void iwl_mvm_tt_handler(struct iwl_mvm *mvm); 2399 void iwl_mvm_thermal_initialize(struct iwl_mvm *mvm, u32 min_backoff); 2400 void iwl_mvm_thermal_exit(struct iwl_mvm *mvm); 2401 void iwl_mvm_set_hw_ctkill_state(struct iwl_mvm *mvm, bool state); 2402 int iwl_mvm_get_temp(struct iwl_mvm *mvm, s32 *temp); 2403 void iwl_mvm_ct_kill_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb); 2404 void iwl_mvm_enter_ctkill(struct iwl_mvm *mvm); 2405 int iwl_mvm_send_temp_report_ths_cmd(struct iwl_mvm *mvm); 2406 int iwl_mvm_ctdp_command(struct iwl_mvm *mvm, u32 op, u32 budget); 2407 2408 #if IS_ENABLED(CONFIG_IWLMEI) 2409 2410 /* vendor commands */ 2411 void iwl_mvm_vendor_cmds_register(struct iwl_mvm *mvm); 2412 2413 #else 2414 2415 static inline void iwl_mvm_vendor_cmds_register(struct iwl_mvm *mvm) {} 2416 2417 #endif 2418 2419 /* Location Aware Regulatory */ 2420 struct iwl_mcc_update_resp_v8 * 2421 iwl_mvm_update_mcc(struct iwl_mvm *mvm, const char *alpha2, 2422 enum iwl_mcc_source src_id); 2423 int iwl_mvm_init_mcc(struct iwl_mvm *mvm); 2424 void iwl_mvm_rx_chub_update_mcc(struct iwl_mvm *mvm, 2425 struct iwl_rx_cmd_buffer *rxb); 2426 struct ieee80211_regdomain *iwl_mvm_get_regdomain(struct wiphy *wiphy, 2427 const char *alpha2, 2428 enum iwl_mcc_source src_id, 2429 bool *changed); 2430 struct ieee80211_regdomain *iwl_mvm_get_current_regdomain(struct iwl_mvm *mvm, 2431 bool *changed); 2432 int iwl_mvm_init_fw_regd(struct iwl_mvm *mvm, bool force_regd_sync); 2433 void iwl_mvm_update_changed_regdom(struct iwl_mvm *mvm); 2434 2435 /* smart fifo */ 2436 int iwl_mvm_sf_update(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2437 bool added_vif); 2438 2439 /* FTM responder */ 2440 int iwl_mvm_ftm_start_responder(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2441 struct ieee80211_bss_conf *bss_conf); 2442 void iwl_mvm_ftm_restart_responder(struct iwl_mvm *mvm, 2443 struct ieee80211_vif *vif, 2444 struct ieee80211_bss_conf *bss_conf); 2445 void iwl_mvm_ftm_responder_stats(struct iwl_mvm *mvm, 2446 struct iwl_rx_cmd_buffer *rxb); 2447 int iwl_mvm_ftm_resp_remove_pasn_sta(struct iwl_mvm *mvm, 2448 struct ieee80211_vif *vif, u8 *addr); 2449 int iwl_mvm_ftm_respoder_add_pasn_sta(struct iwl_mvm *mvm, 2450 struct ieee80211_vif *vif, 2451 u8 *addr, u32 cipher, u8 *tk, u32 tk_len, 2452 u8 *hltk, u32 hltk_len); 2453 void iwl_mvm_ftm_responder_clear(struct iwl_mvm *mvm, 2454 struct ieee80211_vif *vif); 2455 2456 /* FTM initiator */ 2457 void iwl_mvm_ftm_restart(struct iwl_mvm *mvm); 2458 void iwl_mvm_ftm_range_resp(struct iwl_mvm *mvm, 2459 struct iwl_rx_cmd_buffer *rxb); 2460 void iwl_mvm_ftm_lc_notif(struct iwl_mvm *mvm, 2461 struct iwl_rx_cmd_buffer *rxb); 2462 int iwl_mvm_ftm_start(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2463 struct cfg80211_pmsr_request *request); 2464 void iwl_mvm_ftm_abort(struct iwl_mvm *mvm, struct cfg80211_pmsr_request *req); 2465 void iwl_mvm_ftm_initiator_smooth_config(struct iwl_mvm *mvm); 2466 void iwl_mvm_ftm_initiator_smooth_stop(struct iwl_mvm *mvm); 2467 int iwl_mvm_ftm_add_pasn_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2468 u8 *addr, u32 cipher, u8 *tk, u32 tk_len, 2469 u8 *hltk, u32 hltk_len); 2470 void iwl_mvm_ftm_remove_pasn_sta(struct iwl_mvm *mvm, u8 *addr); 2471 2472 /* TDLS */ 2473 2474 /* 2475 * We use TID 4 (VI) as a FW-used-only TID when TDLS connections are present. 2476 * This TID is marked as used vs the AP and all connected TDLS peers. 2477 */ 2478 #define IWL_MVM_TDLS_FW_TID 4 2479 2480 int iwl_mvm_tdls_sta_count(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2481 void iwl_mvm_teardown_tdls_peers(struct iwl_mvm *mvm); 2482 void iwl_mvm_recalc_tdls_state(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2483 bool sta_added); 2484 void iwl_mvm_mac_mgd_protect_tdls_discover(struct ieee80211_hw *hw, 2485 struct ieee80211_vif *vif, 2486 unsigned int link_id); 2487 int iwl_mvm_tdls_channel_switch(struct ieee80211_hw *hw, 2488 struct ieee80211_vif *vif, 2489 struct ieee80211_sta *sta, u8 oper_class, 2490 struct cfg80211_chan_def *chandef, 2491 struct sk_buff *tmpl_skb, u32 ch_sw_tm_ie); 2492 void iwl_mvm_tdls_recv_channel_switch(struct ieee80211_hw *hw, 2493 struct ieee80211_vif *vif, 2494 struct ieee80211_tdls_ch_sw_params *params); 2495 void iwl_mvm_tdls_cancel_channel_switch(struct ieee80211_hw *hw, 2496 struct ieee80211_vif *vif, 2497 struct ieee80211_sta *sta); 2498 void iwl_mvm_rx_tdls_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb); 2499 void iwl_mvm_tdls_ch_switch_work(struct work_struct *work); 2500 2501 void iwl_mvm_sync_rx_queues_internal(struct iwl_mvm *mvm, 2502 enum iwl_mvm_rxq_notif_type type, 2503 bool sync, 2504 const void *data, u32 size); 2505 struct ieee80211_vif *iwl_mvm_get_bss_vif(struct iwl_mvm *mvm); 2506 struct ieee80211_vif *iwl_mvm_get_vif_by_macid(struct iwl_mvm *mvm, u32 macid); 2507 bool iwl_mvm_is_vif_assoc(struct iwl_mvm *mvm); 2508 2509 #define MVM_TCM_PERIOD_MSEC 500 2510 #define MVM_TCM_PERIOD (HZ * MVM_TCM_PERIOD_MSEC / 1000) 2511 #define MVM_LL_PERIOD (10 * HZ) 2512 void iwl_mvm_tcm_work(struct work_struct *work); 2513 void iwl_mvm_recalc_tcm(struct iwl_mvm *mvm); 2514 void iwl_mvm_pause_tcm(struct iwl_mvm *mvm, bool with_cancel); 2515 void iwl_mvm_resume_tcm(struct iwl_mvm *mvm); 2516 void iwl_mvm_tcm_add_vif(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2517 void iwl_mvm_tcm_rm_vif(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2518 u8 iwl_mvm_tcm_load_percentage(u32 airtime, u32 elapsed); 2519 2520 void iwl_mvm_nic_restart(struct iwl_mvm *mvm, bool fw_error); 2521 unsigned int iwl_mvm_get_wd_timeout(struct iwl_mvm *mvm, 2522 struct ieee80211_vif *vif, 2523 bool tdls, bool cmd_q); 2524 void iwl_mvm_connection_loss(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2525 const char *errmsg); 2526 void iwl_mvm_event_frame_timeout_callback(struct iwl_mvm *mvm, 2527 struct ieee80211_vif *vif, 2528 const struct ieee80211_sta *sta, 2529 u16 tid); 2530 void iwl_mvm_mei_scan_filter_init(struct iwl_mei_scan_filter *mei_scan_filter); 2531 2532 void iwl_mvm_ptp_init(struct iwl_mvm *mvm); 2533 void iwl_mvm_ptp_remove(struct iwl_mvm *mvm); 2534 u64 iwl_mvm_ptp_get_adj_time(struct iwl_mvm *mvm, u64 base_time); 2535 int iwl_mvm_sar_select_profile(struct iwl_mvm *mvm, int prof_a, int prof_b); 2536 int iwl_mvm_get_sar_geo_profile(struct iwl_mvm *mvm); 2537 int iwl_mvm_ppag_send_cmd(struct iwl_mvm *mvm); 2538 void iwl_mvm_get_bios_tables(struct iwl_mvm *mvm); 2539 #ifdef CONFIG_IWLWIFI_DEBUGFS 2540 void iwl_mvm_link_sta_add_debugfs(struct ieee80211_hw *hw, 2541 struct ieee80211_vif *vif, 2542 struct ieee80211_link_sta *link_sta, 2543 struct dentry *dir); 2544 void iwl_mvm_link_add_debugfs(struct ieee80211_hw *hw, 2545 struct ieee80211_vif *vif, 2546 struct ieee80211_bss_conf *link_conf, 2547 struct dentry *dir); 2548 #endif 2549 2550 /* new MLD related APIs */ 2551 int iwl_mvm_sec_key_add(struct iwl_mvm *mvm, 2552 struct ieee80211_vif *vif, 2553 struct ieee80211_sta *sta, 2554 struct ieee80211_key_conf *keyconf); 2555 int iwl_mvm_sec_key_del(struct iwl_mvm *mvm, 2556 struct ieee80211_vif *vif, 2557 struct ieee80211_sta *sta, 2558 struct ieee80211_key_conf *keyconf); 2559 int iwl_mvm_sec_key_del_pasn(struct iwl_mvm *mvm, 2560 struct ieee80211_vif *vif, 2561 u32 sta_mask, 2562 struct ieee80211_key_conf *keyconf); 2563 void iwl_mvm_sec_key_remove_ap(struct iwl_mvm *mvm, 2564 struct ieee80211_vif *vif, 2565 struct iwl_mvm_vif_link_info *link, 2566 unsigned int link_id); 2567 int iwl_mvm_mld_update_sta_keys(struct iwl_mvm *mvm, 2568 struct ieee80211_vif *vif, 2569 struct ieee80211_sta *sta, 2570 u32 old_sta_mask, 2571 u32 new_sta_mask); 2572 int iwl_mvm_mld_send_key(struct iwl_mvm *mvm, u32 sta_mask, u32 key_flags, 2573 struct ieee80211_key_conf *keyconf); 2574 u32 iwl_mvm_get_sec_flags(struct iwl_mvm *mvm, 2575 struct ieee80211_vif *vif, 2576 struct ieee80211_sta *sta, 2577 struct ieee80211_key_conf *keyconf); 2578 2579 bool iwl_rfi_supported(struct iwl_mvm *mvm); 2580 int iwl_rfi_send_config_cmd(struct iwl_mvm *mvm, 2581 struct iwl_rfi_lut_entry *rfi_table); 2582 struct iwl_rfi_freq_table_resp_cmd *iwl_rfi_get_freq_table(struct iwl_mvm *mvm); 2583 void iwl_rfi_deactivate_notif_handler(struct iwl_mvm *mvm, 2584 struct iwl_rx_cmd_buffer *rxb); 2585 2586 static inline u8 iwl_mvm_phy_band_from_nl80211(enum nl80211_band band) 2587 { 2588 switch (band) { 2589 case NL80211_BAND_2GHZ: 2590 return PHY_BAND_24; 2591 case NL80211_BAND_5GHZ: 2592 return PHY_BAND_5; 2593 case NL80211_BAND_6GHZ: 2594 return PHY_BAND_6; 2595 default: 2596 WARN_ONCE(1, "Unsupported band (%u)\n", band); 2597 return PHY_BAND_5; 2598 } 2599 } 2600 2601 static inline u8 iwl_mvm_nl80211_band_from_phy(u8 phy_band) 2602 { 2603 switch (phy_band) { 2604 case PHY_BAND_24: 2605 return NL80211_BAND_2GHZ; 2606 case PHY_BAND_5: 2607 return NL80211_BAND_5GHZ; 2608 case PHY_BAND_6: 2609 return NL80211_BAND_6GHZ; 2610 default: 2611 WARN_ONCE(1, "Unsupported phy band (%u)\n", phy_band); 2612 return NL80211_BAND_5GHZ; 2613 } 2614 } 2615 2616 /* Channel Switch */ 2617 void iwl_mvm_channel_switch_disconnect_wk(struct work_struct *wk); 2618 int iwl_mvm_post_channel_switch(struct ieee80211_hw *hw, 2619 struct ieee80211_vif *vif, 2620 struct ieee80211_bss_conf *link); 2621 2622 /* Channel Context */ 2623 /** 2624 * struct iwl_mvm_switch_vif_chanctx_ops - callbacks for switch_vif_chanctx() 2625 * 2626 * Since the only difference between both MLD and 2627 * non-MLD versions of switch_vif_chanctx() is these function calls, 2628 * each version will send its specific function calls to 2629 * %iwl_mvm_switch_vif_chanctx_common(). 2630 * 2631 * @__assign_vif_chanctx: pointer to the function that assigns a chanctx to 2632 * a given vif 2633 * @__unassign_vif_chanctx: pointer to the function that unassigns a chanctx to 2634 * a given vif 2635 */ 2636 struct iwl_mvm_switch_vif_chanctx_ops { 2637 int (*__assign_vif_chanctx)(struct iwl_mvm *mvm, 2638 struct ieee80211_vif *vif, 2639 struct ieee80211_bss_conf *link_conf, 2640 struct ieee80211_chanctx_conf *ctx, 2641 bool switching_chanctx); 2642 void (*__unassign_vif_chanctx)(struct iwl_mvm *mvm, 2643 struct ieee80211_vif *vif, 2644 struct ieee80211_bss_conf *link_conf, 2645 struct ieee80211_chanctx_conf *ctx, 2646 bool switching_chanctx); 2647 }; 2648 2649 int 2650 iwl_mvm_switch_vif_chanctx_common(struct ieee80211_hw *hw, 2651 struct ieee80211_vif_chanctx_switch *vifs, 2652 int n_vifs, 2653 enum ieee80211_chanctx_switch_mode mode, 2654 const struct iwl_mvm_switch_vif_chanctx_ops *ops); 2655 2656 /* Channel info utils */ 2657 static inline bool iwl_mvm_has_ultra_hb_channel(struct iwl_mvm *mvm) 2658 { 2659 return fw_has_capa(&mvm->fw->ucode_capa, 2660 IWL_UCODE_TLV_CAPA_ULTRA_HB_CHANNELS); 2661 } 2662 2663 static inline void *iwl_mvm_chan_info_cmd_tail(struct iwl_mvm *mvm, 2664 struct iwl_fw_channel_info *ci) 2665 { 2666 return (u8 *)ci + (iwl_mvm_has_ultra_hb_channel(mvm) ? 2667 sizeof(struct iwl_fw_channel_info) : 2668 sizeof(struct iwl_fw_channel_info_v1)); 2669 } 2670 2671 static inline size_t iwl_mvm_chan_info_padding(struct iwl_mvm *mvm) 2672 { 2673 return iwl_mvm_has_ultra_hb_channel(mvm) ? 0 : 2674 sizeof(struct iwl_fw_channel_info) - 2675 sizeof(struct iwl_fw_channel_info_v1); 2676 } 2677 2678 static inline void iwl_mvm_set_chan_info(struct iwl_mvm *mvm, 2679 struct iwl_fw_channel_info *ci, 2680 u32 chan, u8 band, u8 width, 2681 u8 ctrl_pos) 2682 { 2683 if (iwl_mvm_has_ultra_hb_channel(mvm)) { 2684 ci->channel = cpu_to_le32(chan); 2685 ci->band = band; 2686 ci->width = width; 2687 ci->ctrl_pos = ctrl_pos; 2688 } else { 2689 struct iwl_fw_channel_info_v1 *ci_v1 = 2690 (struct iwl_fw_channel_info_v1 *)ci; 2691 2692 ci_v1->channel = chan; 2693 ci_v1->band = band; 2694 ci_v1->width = width; 2695 ci_v1->ctrl_pos = ctrl_pos; 2696 } 2697 } 2698 2699 static inline void 2700 iwl_mvm_set_chan_info_chandef(struct iwl_mvm *mvm, 2701 struct iwl_fw_channel_info *ci, 2702 const struct cfg80211_chan_def *chandef) 2703 { 2704 enum nl80211_band band = chandef->chan->band; 2705 2706 iwl_mvm_set_chan_info(mvm, ci, chandef->chan->hw_value, 2707 iwl_mvm_phy_band_from_nl80211(band), 2708 iwl_mvm_get_channel_width(chandef), 2709 iwl_mvm_get_ctrl_pos(chandef)); 2710 } 2711 2712 static inline int iwl_umac_scan_get_max_profiles(const struct iwl_fw *fw) 2713 { 2714 u8 ver = iwl_fw_lookup_cmd_ver(fw, SCAN_OFFLOAD_UPDATE_PROFILES_CMD, 2715 IWL_FW_CMD_VER_UNKNOWN); 2716 return (ver == IWL_FW_CMD_VER_UNKNOWN || ver < 3) ? 2717 IWL_SCAN_MAX_PROFILES : IWL_SCAN_MAX_PROFILES_V2; 2718 } 2719 2720 static inline 2721 enum iwl_location_cipher iwl_mvm_cipher_to_location_cipher(u32 cipher) 2722 { 2723 switch (cipher) { 2724 case WLAN_CIPHER_SUITE_CCMP: 2725 return IWL_LOCATION_CIPHER_CCMP_128; 2726 case WLAN_CIPHER_SUITE_GCMP: 2727 return IWL_LOCATION_CIPHER_GCMP_128; 2728 case WLAN_CIPHER_SUITE_GCMP_256: 2729 return IWL_LOCATION_CIPHER_GCMP_256; 2730 default: 2731 return IWL_LOCATION_CIPHER_INVALID; 2732 } 2733 } 2734 2735 struct iwl_mvm_csme_conn_info *iwl_mvm_get_csme_conn_info(struct iwl_mvm *mvm); 2736 static inline int iwl_mvm_mei_get_ownership(struct iwl_mvm *mvm) 2737 { 2738 if (mvm->mei_registered) 2739 return iwl_mei_get_ownership(); 2740 return 0; 2741 } 2742 2743 static inline void iwl_mvm_mei_tx_copy_to_csme(struct iwl_mvm *mvm, 2744 struct sk_buff *skb, 2745 unsigned int ivlen) 2746 { 2747 if (mvm->mei_registered) 2748 iwl_mei_tx_copy_to_csme(skb, ivlen); 2749 } 2750 2751 static inline void iwl_mvm_mei_host_disassociated(struct iwl_mvm *mvm) 2752 { 2753 if (mvm->mei_registered) 2754 iwl_mei_host_disassociated(); 2755 } 2756 2757 static inline void iwl_mvm_mei_device_state(struct iwl_mvm *mvm, bool up) 2758 { 2759 if (mvm->mei_registered) 2760 iwl_mei_device_state(up); 2761 } 2762 2763 static inline void iwl_mvm_mei_set_sw_rfkill_state(struct iwl_mvm *mvm) 2764 { 2765 bool sw_rfkill = 2766 mvm->hw_registered ? rfkill_soft_blocked(mvm->hw->wiphy->rfkill) : false; 2767 2768 if (mvm->mei_registered) 2769 iwl_mei_set_rfkill_state(iwl_mvm_is_radio_killed(mvm), 2770 sw_rfkill); 2771 } 2772 2773 static inline bool iwl_mvm_mei_filter_scan(struct iwl_mvm *mvm, 2774 struct sk_buff *skb) 2775 { 2776 struct ieee80211_mgmt *mgmt = (void *)skb->data; 2777 2778 if (mvm->mei_scan_filter.is_mei_limited_scan && 2779 (ieee80211_is_probe_resp(mgmt->frame_control) || 2780 ieee80211_is_beacon(mgmt->frame_control))) { 2781 skb_queue_tail(&mvm->mei_scan_filter.scan_res, skb); 2782 schedule_work(&mvm->mei_scan_filter.scan_work); 2783 return true; 2784 } 2785 2786 return false; 2787 } 2788 2789 void iwl_mvm_send_roaming_forbidden_event(struct iwl_mvm *mvm, 2790 struct ieee80211_vif *vif, 2791 bool forbidden); 2792 2793 /* Callbacks for ieee80211_ops */ 2794 void iwl_mvm_mac_tx(struct ieee80211_hw *hw, 2795 struct ieee80211_tx_control *control, struct sk_buff *skb); 2796 void iwl_mvm_mac_wake_tx_queue(struct ieee80211_hw *hw, 2797 struct ieee80211_txq *txq); 2798 2799 int iwl_mvm_mac_ampdu_action(struct ieee80211_hw *hw, 2800 struct ieee80211_vif *vif, 2801 struct ieee80211_ampdu_params *params); 2802 int iwl_mvm_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant); 2803 int iwl_mvm_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant); 2804 int iwl_mvm_mac_start(struct ieee80211_hw *hw); 2805 void iwl_mvm_mac_reconfig_complete(struct ieee80211_hw *hw, 2806 enum ieee80211_reconfig_type reconfig_type); 2807 void iwl_mvm_mac_stop(struct ieee80211_hw *hw); 2808 static inline int iwl_mvm_mac_config(struct ieee80211_hw *hw, u32 changed) 2809 { 2810 return 0; 2811 } 2812 2813 u64 iwl_mvm_prepare_multicast(struct ieee80211_hw *hw, 2814 struct netdev_hw_addr_list *mc_list); 2815 2816 void iwl_mvm_configure_filter(struct ieee80211_hw *hw, 2817 unsigned int changed_flags, 2818 unsigned int *total_flags, u64 multicast); 2819 int iwl_mvm_mac_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 2820 struct ieee80211_scan_request *hw_req); 2821 void iwl_mvm_mac_cancel_hw_scan(struct ieee80211_hw *hw, 2822 struct ieee80211_vif *vif); 2823 void iwl_mvm_sta_pre_rcu_remove(struct ieee80211_hw *hw, 2824 struct ieee80211_vif *vif, 2825 struct ieee80211_sta *sta); 2826 void iwl_mvm_mac_sta_notify(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 2827 enum sta_notify_cmd cmd, 2828 struct ieee80211_sta *sta); 2829 void 2830 iwl_mvm_mac_allow_buffered_frames(struct ieee80211_hw *hw, 2831 struct ieee80211_sta *sta, u16 tids, 2832 int num_frames, 2833 enum ieee80211_frame_release_type reason, 2834 bool more_data); 2835 void 2836 iwl_mvm_mac_release_buffered_frames(struct ieee80211_hw *hw, 2837 struct ieee80211_sta *sta, u16 tids, 2838 int num_frames, 2839 enum ieee80211_frame_release_type reason, 2840 bool more_data); 2841 int iwl_mvm_mac_set_rts_threshold(struct ieee80211_hw *hw, u32 value); 2842 void iwl_mvm_sta_rc_update(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 2843 struct ieee80211_sta *sta, u32 changed); 2844 void iwl_mvm_mac_mgd_prepare_tx(struct ieee80211_hw *hw, 2845 struct ieee80211_vif *vif, 2846 struct ieee80211_prep_tx_info *info); 2847 void iwl_mvm_mac_mgd_complete_tx(struct ieee80211_hw *hw, 2848 struct ieee80211_vif *vif, 2849 struct ieee80211_prep_tx_info *info); 2850 void iwl_mvm_mac_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 2851 u32 queues, bool drop); 2852 void iwl_mvm_mac_flush_sta(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 2853 struct ieee80211_sta *sta); 2854 int iwl_mvm_mac_sched_scan_start(struct ieee80211_hw *hw, 2855 struct ieee80211_vif *vif, 2856 struct cfg80211_sched_scan_request *req, 2857 struct ieee80211_scan_ies *ies); 2858 int iwl_mvm_mac_sched_scan_stop(struct ieee80211_hw *hw, 2859 struct ieee80211_vif *vif); 2860 int iwl_mvm_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 2861 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 2862 struct ieee80211_key_conf *key); 2863 void iwl_mvm_mac_update_tkip_key(struct ieee80211_hw *hw, 2864 struct ieee80211_vif *vif, 2865 struct ieee80211_key_conf *keyconf, 2866 struct ieee80211_sta *sta, 2867 u32 iv32, u16 *phase1key); 2868 int iwl_mvm_add_chanctx(struct ieee80211_hw *hw, 2869 struct ieee80211_chanctx_conf *ctx); 2870 void iwl_mvm_remove_chanctx(struct ieee80211_hw *hw, 2871 struct ieee80211_chanctx_conf *ctx); 2872 void iwl_mvm_change_chanctx(struct ieee80211_hw *hw, 2873 struct ieee80211_chanctx_conf *ctx, u32 changed); 2874 int iwl_mvm_tx_last_beacon(struct ieee80211_hw *hw); 2875 void iwl_mvm_channel_switch(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 2876 struct ieee80211_channel_switch *chsw); 2877 int iwl_mvm_pre_channel_switch(struct iwl_mvm *mvm, 2878 struct ieee80211_vif *vif, 2879 struct ieee80211_channel_switch *chsw); 2880 void iwl_mvm_abort_channel_switch(struct ieee80211_hw *hw, 2881 struct ieee80211_vif *vif, 2882 struct ieee80211_bss_conf *link_conf); 2883 void iwl_mvm_channel_switch_rx_beacon(struct ieee80211_hw *hw, 2884 struct ieee80211_vif *vif, 2885 struct ieee80211_channel_switch *chsw); 2886 void iwl_mvm_mac_event_callback(struct ieee80211_hw *hw, 2887 struct ieee80211_vif *vif, 2888 const struct ieee80211_event *event); 2889 void iwl_mvm_sync_rx_queues(struct ieee80211_hw *hw); 2890 int iwl_mvm_mac_testmode_cmd(struct ieee80211_hw *hw, 2891 struct ieee80211_vif *vif, 2892 void *data, int len); 2893 int iwl_mvm_mac_get_survey(struct ieee80211_hw *hw, int idx, 2894 struct survey_info *survey); 2895 void iwl_mvm_mac_sta_statistics(struct ieee80211_hw *hw, 2896 struct ieee80211_vif *vif, 2897 struct ieee80211_sta *sta, 2898 struct station_info *sinfo); 2899 int 2900 iwl_mvm_mac_get_ftm_responder_stats(struct ieee80211_hw *hw, 2901 struct ieee80211_vif *vif, 2902 struct cfg80211_ftm_responder_stats *stats); 2903 int iwl_mvm_start_pmsr(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 2904 struct cfg80211_pmsr_request *request); 2905 void iwl_mvm_abort_pmsr(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 2906 struct cfg80211_pmsr_request *request); 2907 2908 bool iwl_mvm_have_links_same_channel(struct iwl_mvm_vif *vif1, 2909 struct iwl_mvm_vif *vif2); 2910 bool iwl_mvm_vif_is_active(struct iwl_mvm_vif *mvmvif); 2911 int iwl_mvm_set_tx_power(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2912 s16 tx_power); 2913 int iwl_mvm_set_hw_timestamp(struct ieee80211_hw *hw, 2914 struct ieee80211_vif *vif, 2915 struct cfg80211_set_hw_timestamp *hwts); 2916 int iwl_mvm_update_mu_groups(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2917 bool iwl_mvm_enable_fils(struct iwl_mvm *mvm, 2918 struct ieee80211_chanctx_conf *ctx); 2919 bool iwl_mvm_is_ftm_responder_chanctx(struct iwl_mvm *mvm, 2920 struct ieee80211_chanctx_conf *ctx); 2921 2922 static inline struct cfg80211_chan_def * 2923 iwl_mvm_chanctx_def(struct iwl_mvm *mvm, struct ieee80211_chanctx_conf *ctx) 2924 { 2925 bool use_def = iwl_mvm_is_ftm_responder_chanctx(mvm, ctx) || 2926 iwl_mvm_enable_fils(mvm, ctx); 2927 2928 return use_def ? &ctx->def : &ctx->min_def; 2929 } 2930 2931 void iwl_mvm_roc_duration_and_delay(struct ieee80211_vif *vif, 2932 u32 duration_ms, 2933 u32 *duration_tu, 2934 u32 *delay); 2935 int iwl_mvm_roc_add_cmd(struct iwl_mvm *mvm, 2936 struct ieee80211_channel *channel, 2937 struct ieee80211_vif *vif, 2938 int duration, u32 activity); 2939 2940 /* EMLSR */ 2941 bool iwl_mvm_vif_has_esr_cap(struct iwl_mvm *mvm, struct ieee80211_vif *vif); 2942 void iwl_mvm_block_esr(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2943 enum iwl_mvm_esr_state reason, 2944 u8 link_to_keep); 2945 int iwl_mvm_block_esr_sync(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2946 enum iwl_mvm_esr_state reason); 2947 void iwl_mvm_unblock_esr(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2948 enum iwl_mvm_esr_state reason); 2949 void iwl_mvm_exit_esr(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2950 enum iwl_mvm_esr_state reason, 2951 u8 link_to_keep); 2952 s8 iwl_mvm_get_esr_rssi_thresh(struct iwl_mvm *mvm, 2953 const struct cfg80211_chan_def *chandef, 2954 bool low); 2955 void iwl_mvm_bt_coex_update_link_esr(struct iwl_mvm *mvm, 2956 struct ieee80211_vif *vif, 2957 int link_id); 2958 bool 2959 iwl_mvm_bt_coex_calculate_esr_mode(struct iwl_mvm *mvm, 2960 struct ieee80211_vif *vif, 2961 s32 link_rssi, 2962 bool primary); 2963 int iwl_mvm_esr_non_bss_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2964 unsigned int link_id, bool active); 2965 2966 void 2967 iwl_mvm_send_ap_tx_power_constraint_cmd(struct iwl_mvm *mvm, 2968 struct ieee80211_vif *vif, 2969 struct ieee80211_bss_conf *bss_conf, 2970 bool is_ap); 2971 #endif /* __IWL_MVM_H__ */ 2972