1 /* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */
2 /*
3  * Copyright (C) 2012-2014, 2018-2020 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/leds.h>
13 #include <linux/in6.h>
14 
15 #ifdef CONFIG_THERMAL
16 #include <linux/thermal.h>
17 #endif
18 
19 #include "iwl-op-mode.h"
20 #include "iwl-trans.h"
21 #include "fw/notif-wait.h"
22 #include "iwl-eeprom-parse.h"
23 #include "fw/file.h"
24 #include "iwl-config.h"
25 #include "sta.h"
26 #include "fw-api.h"
27 #include "constants.h"
28 #include "fw/runtime.h"
29 #include "fw/dbg.h"
30 #include "fw/acpi.h"
31 #include "iwl-nvm-parse.h"
32 
33 #include <linux/average.h>
34 
35 #define IWL_MVM_MAX_ADDRESSES		5
36 /* RSSI offset for WkP */
37 #define IWL_RSSI_OFFSET 50
38 #define IWL_MVM_MISSED_BEACONS_THRESHOLD 8
39 #define IWL_MVM_MISSED_BEACONS_THRESHOLD_LONG 16
40 
41 /* A TimeUnit is 1024 microsecond */
42 #define MSEC_TO_TU(_msec)	(_msec*1000/1024)
43 
44 /* For GO, this value represents the number of TUs before CSA "beacon
45  * 0" TBTT when the CSA time-event needs to be scheduled to start.  It
46  * must be big enough to ensure that we switch in time.
47  */
48 #define IWL_MVM_CHANNEL_SWITCH_TIME_GO		40
49 
50 /* For client, this value represents the number of TUs before CSA
51  * "beacon 1" TBTT, instead.  This is because we don't know when the
52  * GO/AP will be in the new channel, so we switch early enough.
53  */
54 #define IWL_MVM_CHANNEL_SWITCH_TIME_CLIENT	10
55 
56 /*
57  * This value (in TUs) is used to fine tune the CSA NoA end time which should
58  * be just before "beacon 0" TBTT.
59  */
60 #define IWL_MVM_CHANNEL_SWITCH_MARGIN 4
61 
62 /*
63  * Number of beacons to transmit on a new channel until we unblock tx to
64  * the stations, even if we didn't identify them on a new channel
65  */
66 #define IWL_MVM_CS_UNBLOCK_TX_TIMEOUT 3
67 
68 /* offchannel queue towards mac80211 */
69 #define IWL_MVM_OFFCHANNEL_QUEUE 0
70 
71 extern const struct ieee80211_ops iwl_mvm_hw_ops;
72 
73 /**
74  * struct iwl_mvm_mod_params - module parameters for iwlmvm
75  * @init_dbg: if true, then the NIC won't be stopped if the INIT fw asserted.
76  *	We will register to mac80211 to have testmode working. The NIC must not
77  *	be up'ed after the INIT fw asserted. This is useful to be able to use
78  *	proprietary tools over testmode to debug the INIT fw.
79  * @power_scheme: one of enum iwl_power_scheme
80  */
81 struct iwl_mvm_mod_params {
82 	bool init_dbg;
83 	int power_scheme;
84 };
85 extern struct iwl_mvm_mod_params iwlmvm_mod_params;
86 
87 struct iwl_mvm_phy_ctxt {
88 	u16 id;
89 	u16 color;
90 	u32 ref;
91 
92 	enum nl80211_chan_width width;
93 
94 	/*
95 	 * TODO: This should probably be removed. Currently here only for rate
96 	 * scaling algorithm
97 	 */
98 	struct ieee80211_channel *channel;
99 };
100 
101 struct iwl_mvm_time_event_data {
102 	struct ieee80211_vif *vif;
103 	struct list_head list;
104 	unsigned long end_jiffies;
105 	u32 duration;
106 	bool running;
107 	u32 uid;
108 
109 	/*
110 	 * The access to the 'id' field must be done when the
111 	 * mvm->time_event_lock is held, as it value is used to indicate
112 	 * if the te is in the time event list or not (when id == TE_MAX)
113 	 */
114 	u32 id;
115 };
116 
117  /* Power management */
118 
119 /**
120  * enum iwl_power_scheme
121  * @IWL_POWER_LEVEL_CAM - Continuously Active Mode
122  * @IWL_POWER_LEVEL_BPS - Balanced Power Save (default)
123  * @IWL_POWER_LEVEL_LP  - Low Power
124  */
125 enum iwl_power_scheme {
126 	IWL_POWER_SCHEME_CAM = 1,
127 	IWL_POWER_SCHEME_BPS,
128 	IWL_POWER_SCHEME_LP
129 };
130 
131 #define IWL_CONN_MAX_LISTEN_INTERVAL	10
132 #define IWL_UAPSD_MAX_SP		IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL
133 
134 #ifdef CONFIG_IWLWIFI_DEBUGFS
135 enum iwl_dbgfs_pm_mask {
136 	MVM_DEBUGFS_PM_KEEP_ALIVE = BIT(0),
137 	MVM_DEBUGFS_PM_SKIP_OVER_DTIM = BIT(1),
138 	MVM_DEBUGFS_PM_SKIP_DTIM_PERIODS = BIT(2),
139 	MVM_DEBUGFS_PM_RX_DATA_TIMEOUT = BIT(3),
140 	MVM_DEBUGFS_PM_TX_DATA_TIMEOUT = BIT(4),
141 	MVM_DEBUGFS_PM_LPRX_ENA = BIT(6),
142 	MVM_DEBUGFS_PM_LPRX_RSSI_THRESHOLD = BIT(7),
143 	MVM_DEBUGFS_PM_SNOOZE_ENABLE = BIT(8),
144 	MVM_DEBUGFS_PM_UAPSD_MISBEHAVING = BIT(9),
145 	MVM_DEBUGFS_PM_USE_PS_POLL = BIT(10),
146 };
147 
148 struct iwl_dbgfs_pm {
149 	u16 keep_alive_seconds;
150 	u32 rx_data_timeout;
151 	u32 tx_data_timeout;
152 	bool skip_over_dtim;
153 	u8 skip_dtim_periods;
154 	bool lprx_ena;
155 	u32 lprx_rssi_threshold;
156 	bool snooze_ena;
157 	bool uapsd_misbehaving;
158 	bool use_ps_poll;
159 	int mask;
160 };
161 
162 /* beacon filtering */
163 
164 enum iwl_dbgfs_bf_mask {
165 	MVM_DEBUGFS_BF_ENERGY_DELTA = BIT(0),
166 	MVM_DEBUGFS_BF_ROAMING_ENERGY_DELTA = BIT(1),
167 	MVM_DEBUGFS_BF_ROAMING_STATE = BIT(2),
168 	MVM_DEBUGFS_BF_TEMP_THRESHOLD = BIT(3),
169 	MVM_DEBUGFS_BF_TEMP_FAST_FILTER = BIT(4),
170 	MVM_DEBUGFS_BF_TEMP_SLOW_FILTER = BIT(5),
171 	MVM_DEBUGFS_BF_ENABLE_BEACON_FILTER = BIT(6),
172 	MVM_DEBUGFS_BF_DEBUG_FLAG = BIT(7),
173 	MVM_DEBUGFS_BF_ESCAPE_TIMER = BIT(8),
174 	MVM_DEBUGFS_BA_ESCAPE_TIMER = BIT(9),
175 	MVM_DEBUGFS_BA_ENABLE_BEACON_ABORT = BIT(10),
176 };
177 
178 struct iwl_dbgfs_bf {
179 	u32 bf_energy_delta;
180 	u32 bf_roaming_energy_delta;
181 	u32 bf_roaming_state;
182 	u32 bf_temp_threshold;
183 	u32 bf_temp_fast_filter;
184 	u32 bf_temp_slow_filter;
185 	u32 bf_enable_beacon_filter;
186 	u32 bf_debug_flag;
187 	u32 bf_escape_timer;
188 	u32 ba_escape_timer;
189 	u32 ba_enable_beacon_abort;
190 	int mask;
191 };
192 #endif
193 
194 enum iwl_mvm_smps_type_request {
195 	IWL_MVM_SMPS_REQ_BT_COEX,
196 	IWL_MVM_SMPS_REQ_TT,
197 	IWL_MVM_SMPS_REQ_PROT,
198 	NUM_IWL_MVM_SMPS_REQ,
199 };
200 
201 enum iwl_bt_force_ant_mode {
202 	BT_FORCE_ANT_DIS = 0,
203 	BT_FORCE_ANT_AUTO,
204 	BT_FORCE_ANT_BT,
205 	BT_FORCE_ANT_WIFI,
206 
207 	BT_FORCE_ANT_MAX,
208 };
209 
210 /**
211  * struct iwl_mvm_low_latency_force - low latency force mode set by debugfs
212  * @LOW_LATENCY_FORCE_UNSET: unset force mode
213  * @LOW_LATENCY_FORCE_ON: for low latency on
214  * @LOW_LATENCY_FORCE_OFF: for low latency off
215  * @NUM_LOW_LATENCY_FORCE: max num of modes
216  */
217 enum iwl_mvm_low_latency_force {
218 	LOW_LATENCY_FORCE_UNSET,
219 	LOW_LATENCY_FORCE_ON,
220 	LOW_LATENCY_FORCE_OFF,
221 	NUM_LOW_LATENCY_FORCE
222 };
223 
224 /**
225 * struct iwl_mvm_low_latency_cause - low latency set causes
226 * @LOW_LATENCY_TRAFFIC: indicates low latency traffic was detected
227 * @LOW_LATENCY_DEBUGFS: low latency mode set from debugfs
228 * @LOW_LATENCY_VCMD: low latency mode set from vendor command
229 * @LOW_LATENCY_VIF_TYPE: low latency mode set because of vif type (ap)
230 * @LOW_LATENCY_DEBUGFS_FORCE_ENABLE: indicate that force mode is enabled
231 *	the actual set/unset is done with LOW_LATENCY_DEBUGFS_FORCE
232 * @LOW_LATENCY_DEBUGFS_FORCE: low latency force mode from debugfs
233 *	set this with LOW_LATENCY_DEBUGFS_FORCE_ENABLE flag
234 *	in low_latency.
235 */
236 enum iwl_mvm_low_latency_cause {
237 	LOW_LATENCY_TRAFFIC = BIT(0),
238 	LOW_LATENCY_DEBUGFS = BIT(1),
239 	LOW_LATENCY_VCMD = BIT(2),
240 	LOW_LATENCY_VIF_TYPE = BIT(3),
241 	LOW_LATENCY_DEBUGFS_FORCE_ENABLE = BIT(4),
242 	LOW_LATENCY_DEBUGFS_FORCE = BIT(5),
243 };
244 
245 /**
246 * struct iwl_mvm_vif_bf_data - beacon filtering related data
247 * @bf_enabled: indicates if beacon filtering is enabled
248 * @ba_enabled: indicated if beacon abort is enabled
249 * @ave_beacon_signal: average beacon signal
250 * @last_cqm_event: rssi of the last cqm event
251 * @bt_coex_min_thold: minimum threshold for BT coex
252 * @bt_coex_max_thold: maximum threshold for BT coex
253 * @last_bt_coex_event: rssi of the last BT coex event
254 */
255 struct iwl_mvm_vif_bf_data {
256 	bool bf_enabled;
257 	bool ba_enabled;
258 	int ave_beacon_signal;
259 	int last_cqm_event;
260 	int bt_coex_min_thold;
261 	int bt_coex_max_thold;
262 	int last_bt_coex_event;
263 };
264 
265 /**
266  * struct iwl_probe_resp_data - data for NoA/CSA updates
267  * @rcu_head: used for freeing the data on update
268  * @notif: notification data
269  * @noa_len: length of NoA attribute, calculated from the notification
270  */
271 struct iwl_probe_resp_data {
272 	struct rcu_head rcu_head;
273 	struct iwl_probe_resp_data_notif notif;
274 	int noa_len;
275 };
276 
277 /**
278  * struct iwl_mvm_vif - data per Virtual Interface, it is a MAC context
279  * @id: between 0 and 3
280  * @color: to solve races upon MAC addition and removal
281  * @ap_sta_id: the sta_id of the AP - valid only if VIF type is STA
282  * @bssid: BSSID for this (client) interface
283  * @associated: indicates that we're currently associated, used only for
284  *	managing the firmware state in iwl_mvm_bss_info_changed_station()
285  * @ap_assoc_sta_count: count of stations associated to us - valid only
286  *	if VIF type is AP
287  * @uploaded: indicates the MAC context has been added to the device
288  * @ap_ibss_active: indicates that AP/IBSS is configured and that the interface
289  *	should get quota etc.
290  * @pm_enabled - Indicate if MAC power management is allowed
291  * @monitor_active: indicates that monitor context is configured, and that the
292  *	interface should get quota etc.
293  * @low_latency: bit flags for low latency
294  *	see enum &iwl_mvm_low_latency_cause for causes.
295  * @low_latency_actual: boolean, indicates low latency is set,
296  *	as a result from low_latency bit flags and takes force into account.
297  * @ps_disabled: indicates that this interface requires PS to be disabled
298  * @queue_params: QoS params for this MAC
299  * @bcast_sta: station used for broadcast packets. Used by the following
300  *  vifs: P2P_DEVICE, GO and AP.
301  * @beacon_skb: the skb used to hold the AP/GO beacon template
302  * @smps_requests: the SMPS requests of different parts of the driver,
303  *	combined on update to yield the overall request to mac80211.
304  * @beacon_stats: beacon statistics, containing the # of received beacons,
305  *	# of received beacons accumulated over FW restart, and the current
306  *	average signal of beacons retrieved from the firmware
307  * @csa_failed: CSA failed to schedule time event, report an error later
308  * @features: hw features active for this vif
309  * @probe_resp_data: data from FW notification to store NOA and CSA related
310  *	data to be inserted into probe response.
311  */
312 struct iwl_mvm_vif {
313 	struct iwl_mvm *mvm;
314 	u16 id;
315 	u16 color;
316 	u8 ap_sta_id;
317 
318 	u8 bssid[ETH_ALEN];
319 	bool associated;
320 	u8 ap_assoc_sta_count;
321 
322 	u16 cab_queue;
323 
324 	bool uploaded;
325 	bool ap_ibss_active;
326 	bool pm_enabled;
327 	bool monitor_active;
328 	u8 low_latency: 6;
329 	u8 low_latency_actual: 1;
330 	bool ps_disabled;
331 	struct iwl_mvm_vif_bf_data bf_data;
332 
333 	struct {
334 		u32 num_beacons, accu_num_beacons;
335 		u8 avg_signal;
336 	} beacon_stats;
337 
338 	u32 ap_beacon_time;
339 
340 	enum iwl_tsf_id tsf_id;
341 
342 	/*
343 	 * QoS data from mac80211, need to store this here
344 	 * as mac80211 has a separate callback but we need
345 	 * to have the data for the MAC context
346 	 */
347 	struct ieee80211_tx_queue_params queue_params[IEEE80211_NUM_ACS];
348 	struct iwl_mvm_time_event_data time_event_data;
349 	struct iwl_mvm_time_event_data hs_time_event_data;
350 
351 	struct iwl_mvm_int_sta bcast_sta;
352 	struct iwl_mvm_int_sta mcast_sta;
353 
354 	/*
355 	 * Assigned while mac80211 has the interface in a channel context,
356 	 * or, for P2P Device, while it exists.
357 	 */
358 	struct iwl_mvm_phy_ctxt *phy_ctxt;
359 
360 #ifdef CONFIG_PM
361 	/* WoWLAN GTK rekey data */
362 	struct {
363 		u8 kck[NL80211_KCK_EXT_LEN];
364 		u8 kek[NL80211_KEK_EXT_LEN];
365 		size_t kek_len;
366 		size_t kck_len;
367 		u32 akm;
368 		__le64 replay_ctr;
369 		bool valid;
370 	} rekey_data;
371 
372 	int tx_key_idx;
373 
374 	bool seqno_valid;
375 	u16 seqno;
376 #endif
377 
378 #if IS_ENABLED(CONFIG_IPV6)
379 	/* IPv6 addresses for WoWLAN */
380 	struct in6_addr target_ipv6_addrs[IWL_PROTO_OFFLOAD_NUM_IPV6_ADDRS_MAX];
381 	unsigned long tentative_addrs[BITS_TO_LONGS(IWL_PROTO_OFFLOAD_NUM_IPV6_ADDRS_MAX)];
382 	int num_target_ipv6_addrs;
383 #endif
384 
385 #ifdef CONFIG_IWLWIFI_DEBUGFS
386 	struct dentry *dbgfs_dir;
387 	struct dentry *dbgfs_slink;
388 	struct iwl_dbgfs_pm dbgfs_pm;
389 	struct iwl_dbgfs_bf dbgfs_bf;
390 	struct iwl_mac_power_cmd mac_pwr_cmd;
391 	int dbgfs_quota_min;
392 #endif
393 
394 	enum ieee80211_smps_mode smps_requests[NUM_IWL_MVM_SMPS_REQ];
395 
396 	/* FW identified misbehaving AP */
397 	u8 uapsd_misbehaving_bssid[ETH_ALEN];
398 
399 	struct delayed_work uapsd_nonagg_detected_wk;
400 
401 	/* Indicates that CSA countdown may be started */
402 	bool csa_countdown;
403 	bool csa_failed;
404 	u16 csa_target_freq;
405 	u16 csa_count;
406 	u16 csa_misbehave;
407 	struct delayed_work csa_work;
408 
409 	/* Indicates that we are waiting for a beacon on a new channel */
410 	bool csa_bcn_pending;
411 
412 	/* TCP Checksum Offload */
413 	netdev_features_t features;
414 
415 	struct iwl_probe_resp_data __rcu *probe_resp_data;
416 
417 	/* we can only have 2 GTK + 2 IGTK active at a time */
418 	struct ieee80211_key_conf *ap_early_keys[4];
419 
420 	/* 26-tone RU OFDMA transmissions should be blocked */
421 	bool he_ru_2mhz_block;
422 
423 	struct {
424 		struct ieee80211_key_conf __rcu *keys[2];
425 	} bcn_prot;
426 };
427 
428 static inline struct iwl_mvm_vif *
429 iwl_mvm_vif_from_mac80211(struct ieee80211_vif *vif)
430 {
431 	if (!vif)
432 		return NULL;
433 	return (void *)vif->drv_priv;
434 }
435 
436 extern const u8 tid_to_mac80211_ac[];
437 
438 #define IWL_MVM_SCAN_STOPPING_SHIFT	8
439 
440 enum iwl_scan_status {
441 	IWL_MVM_SCAN_REGULAR		= BIT(0),
442 	IWL_MVM_SCAN_SCHED		= BIT(1),
443 	IWL_MVM_SCAN_NETDETECT		= BIT(2),
444 
445 	IWL_MVM_SCAN_STOPPING_REGULAR	= BIT(8),
446 	IWL_MVM_SCAN_STOPPING_SCHED	= BIT(9),
447 	IWL_MVM_SCAN_STOPPING_NETDETECT	= BIT(10),
448 
449 	IWL_MVM_SCAN_REGULAR_MASK	= IWL_MVM_SCAN_REGULAR |
450 					  IWL_MVM_SCAN_STOPPING_REGULAR,
451 	IWL_MVM_SCAN_SCHED_MASK		= IWL_MVM_SCAN_SCHED |
452 					  IWL_MVM_SCAN_STOPPING_SCHED,
453 	IWL_MVM_SCAN_NETDETECT_MASK	= IWL_MVM_SCAN_NETDETECT |
454 					  IWL_MVM_SCAN_STOPPING_NETDETECT,
455 
456 	IWL_MVM_SCAN_STOPPING_MASK	= 0xff << IWL_MVM_SCAN_STOPPING_SHIFT,
457 	IWL_MVM_SCAN_MASK		= 0xff,
458 };
459 
460 enum iwl_mvm_scan_type {
461 	IWL_SCAN_TYPE_NOT_SET,
462 	IWL_SCAN_TYPE_UNASSOC,
463 	IWL_SCAN_TYPE_WILD,
464 	IWL_SCAN_TYPE_MILD,
465 	IWL_SCAN_TYPE_FRAGMENTED,
466 	IWL_SCAN_TYPE_FAST_BALANCE,
467 };
468 
469 enum iwl_mvm_sched_scan_pass_all_states {
470 	SCHED_SCAN_PASS_ALL_DISABLED,
471 	SCHED_SCAN_PASS_ALL_ENABLED,
472 	SCHED_SCAN_PASS_ALL_FOUND,
473 };
474 
475 /**
476  * struct iwl_mvm_tt_mgnt - Thermal Throttling Management structure
477  * @ct_kill_exit: worker to exit thermal kill
478  * @dynamic_smps: Is thermal throttling enabled dynamic_smps?
479  * @tx_backoff: The current thremal throttling tx backoff in uSec.
480  * @min_backoff: The minimal tx backoff due to power restrictions
481  * @params: Parameters to configure the thermal throttling algorithm.
482  * @throttle: Is thermal throttling is active?
483  */
484 struct iwl_mvm_tt_mgmt {
485 	struct delayed_work ct_kill_exit;
486 	bool dynamic_smps;
487 	u32 tx_backoff;
488 	u32 min_backoff;
489 	struct iwl_tt_params params;
490 	bool throttle;
491 };
492 
493 #ifdef CONFIG_THERMAL
494 /**
495  *struct iwl_mvm_thermal_device - thermal zone related data
496  * @temp_trips: temperature thresholds for report
497  * @fw_trips_index: keep indexes to original array - temp_trips
498  * @tzone: thermal zone device data
499 */
500 struct iwl_mvm_thermal_device {
501 	s16 temp_trips[IWL_MAX_DTS_TRIPS];
502 	u8 fw_trips_index[IWL_MAX_DTS_TRIPS];
503 	struct thermal_zone_device *tzone;
504 };
505 
506 /*
507  * struct iwl_mvm_cooling_device
508  * @cur_state: current state
509  * @cdev: struct thermal cooling device
510  */
511 struct iwl_mvm_cooling_device {
512 	u32 cur_state;
513 	struct thermal_cooling_device *cdev;
514 };
515 #endif
516 
517 #define IWL_MVM_NUM_LAST_FRAMES_UCODE_RATES 8
518 
519 struct iwl_mvm_frame_stats {
520 	u32 legacy_frames;
521 	u32 ht_frames;
522 	u32 vht_frames;
523 	u32 bw_20_frames;
524 	u32 bw_40_frames;
525 	u32 bw_80_frames;
526 	u32 bw_160_frames;
527 	u32 sgi_frames;
528 	u32 ngi_frames;
529 	u32 siso_frames;
530 	u32 mimo2_frames;
531 	u32 agg_frames;
532 	u32 ampdu_count;
533 	u32 success_frames;
534 	u32 fail_frames;
535 	u32 last_rates[IWL_MVM_NUM_LAST_FRAMES_UCODE_RATES];
536 	int last_frame_idx;
537 };
538 
539 #define IWL_MVM_DEBUG_SET_TEMPERATURE_DISABLE 0xff
540 #define IWL_MVM_DEBUG_SET_TEMPERATURE_MIN -100
541 #define IWL_MVM_DEBUG_SET_TEMPERATURE_MAX 200
542 
543 enum iwl_mvm_tdls_cs_state {
544 	IWL_MVM_TDLS_SW_IDLE = 0,
545 	IWL_MVM_TDLS_SW_REQ_SENT,
546 	IWL_MVM_TDLS_SW_RESP_RCVD,
547 	IWL_MVM_TDLS_SW_REQ_RCVD,
548 	IWL_MVM_TDLS_SW_ACTIVE,
549 };
550 
551 enum iwl_mvm_traffic_load {
552 	IWL_MVM_TRAFFIC_LOW,
553 	IWL_MVM_TRAFFIC_MEDIUM,
554 	IWL_MVM_TRAFFIC_HIGH,
555 };
556 
557 DECLARE_EWMA(rate, 16, 16)
558 
559 struct iwl_mvm_tcm_mac {
560 	struct {
561 		u32 pkts[IEEE80211_NUM_ACS];
562 		u32 airtime;
563 	} tx;
564 	struct {
565 		u32 pkts[IEEE80211_NUM_ACS];
566 		u32 airtime;
567 		u32 last_ampdu_ref;
568 	} rx;
569 	struct {
570 		/* track AP's transfer in client mode */
571 		u64 rx_bytes;
572 		struct ewma_rate rate;
573 		bool detected;
574 	} uapsd_nonagg_detect;
575 	bool opened_rx_ba_sessions;
576 };
577 
578 struct iwl_mvm_tcm {
579 	struct delayed_work work;
580 	spinlock_t lock; /* used when time elapsed */
581 	unsigned long ts; /* timestamp when period ends */
582 	unsigned long ll_ts;
583 	unsigned long uapsd_nonagg_ts;
584 	bool paused;
585 	struct iwl_mvm_tcm_mac data[NUM_MAC_INDEX_DRIVER];
586 	struct {
587 		u32 elapsed; /* milliseconds for this TCM period */
588 		u32 airtime[NUM_MAC_INDEX_DRIVER];
589 		enum iwl_mvm_traffic_load load[NUM_MAC_INDEX_DRIVER];
590 		enum iwl_mvm_traffic_load band_load[NUM_NL80211_BANDS];
591 		enum iwl_mvm_traffic_load global_load;
592 		bool low_latency[NUM_MAC_INDEX_DRIVER];
593 		bool change[NUM_MAC_INDEX_DRIVER];
594 		bool global_change;
595 	} result;
596 };
597 
598 /**
599  * struct iwl_mvm_reorder_buffer - per ra/tid/queue reorder buffer
600  * @head_sn: reorder window head sn
601  * @num_stored: number of mpdus stored in the buffer
602  * @buf_size: the reorder buffer size as set by the last addba request
603  * @queue: queue of this reorder buffer
604  * @last_amsdu: track last ASMDU SN for duplication detection
605  * @last_sub_index: track ASMDU sub frame index for duplication detection
606  * @reorder_timer: timer for frames are in the reorder buffer. For AMSDU
607  *	it is the time of last received sub-frame
608  * @removed: prevent timer re-arming
609  * @valid: reordering is valid for this queue
610  * @lock: protect reorder buffer internal state
611  * @mvm: mvm pointer, needed for frame timer context
612  * @consec_oldsn_drops: consecutive drops due to old SN
613  * @consec_oldsn_ampdu_gp2: A-MPDU GP2 timestamp to track
614  *	when to apply old SN consecutive drop workaround
615  * @consec_oldsn_prev_drop: track whether or not an MPDU
616  *	that was single/part of the previous A-MPDU was
617  *	dropped due to old SN
618  */
619 struct iwl_mvm_reorder_buffer {
620 	u16 head_sn;
621 	u16 num_stored;
622 	u16 buf_size;
623 	int queue;
624 	u16 last_amsdu;
625 	u8 last_sub_index;
626 	struct timer_list reorder_timer;
627 	bool removed;
628 	bool valid;
629 	spinlock_t lock;
630 	struct iwl_mvm *mvm;
631 	unsigned int consec_oldsn_drops;
632 	u32 consec_oldsn_ampdu_gp2;
633 	unsigned int consec_oldsn_prev_drop:1;
634 } ____cacheline_aligned_in_smp;
635 
636 /**
637  * struct _iwl_mvm_reorder_buf_entry - reorder buffer entry per-queue/per-seqno
638  * @frames: list of skbs stored
639  * @reorder_time: time the packet was stored in the reorder buffer
640  */
641 struct _iwl_mvm_reorder_buf_entry {
642 	struct sk_buff_head frames;
643 	unsigned long reorder_time;
644 };
645 
646 /* make this indirection to get the aligned thing */
647 struct iwl_mvm_reorder_buf_entry {
648 	struct _iwl_mvm_reorder_buf_entry e;
649 }
650 #ifndef __CHECKER__
651 /* sparse doesn't like this construct: "bad integer constant expression" */
652 __aligned(roundup_pow_of_two(sizeof(struct _iwl_mvm_reorder_buf_entry)))
653 #endif
654 ;
655 
656 /**
657  * struct iwl_mvm_baid_data - BA session data
658  * @sta_id: station id
659  * @tid: tid of the session
660  * @baid baid of the session
661  * @timeout: the timeout set in the addba request
662  * @entries_per_queue: # of buffers per queue, this actually gets
663  *	aligned up to avoid cache line sharing between queues
664  * @last_rx: last rx jiffies, updated only if timeout passed from last update
665  * @session_timer: timer to check if BA session expired, runs at 2 * timeout
666  * @mvm: mvm pointer, needed for timer context
667  * @reorder_buf: reorder buffer, allocated per queue
668  * @reorder_buf_data: data
669  */
670 struct iwl_mvm_baid_data {
671 	struct rcu_head rcu_head;
672 	u8 sta_id;
673 	u8 tid;
674 	u8 baid;
675 	u16 timeout;
676 	u16 entries_per_queue;
677 	unsigned long last_rx;
678 	struct timer_list session_timer;
679 	struct iwl_mvm_baid_data __rcu **rcu_ptr;
680 	struct iwl_mvm *mvm;
681 	struct iwl_mvm_reorder_buffer reorder_buf[IWL_MAX_RX_HW_QUEUES];
682 	struct iwl_mvm_reorder_buf_entry entries[];
683 };
684 
685 static inline struct iwl_mvm_baid_data *
686 iwl_mvm_baid_data_from_reorder_buf(struct iwl_mvm_reorder_buffer *buf)
687 {
688 	return (void *)((u8 *)buf -
689 			offsetof(struct iwl_mvm_baid_data, reorder_buf) -
690 			sizeof(*buf) * buf->queue);
691 }
692 
693 /*
694  * enum iwl_mvm_queue_status - queue status
695  * @IWL_MVM_QUEUE_FREE: the queue is not allocated nor reserved
696  *	Basically, this means that this queue can be used for any purpose
697  * @IWL_MVM_QUEUE_RESERVED: queue is reserved but not yet in use
698  *	This is the state of a queue that has been dedicated for some RATID
699  *	(agg'd or not), but that hasn't yet gone through the actual enablement
700  *	of iwl_mvm_enable_txq(), and therefore no traffic can go through it yet.
701  *	Note that in this state there is no requirement to already know what TID
702  *	should be used with this queue, it is just marked as a queue that will
703  *	be used, and shouldn't be allocated to anyone else.
704  * @IWL_MVM_QUEUE_READY: queue is ready to be used
705  *	This is the state of a queue that has been fully configured (including
706  *	SCD pointers, etc), has a specific RA/TID assigned to it, and can be
707  *	used to send traffic.
708  * @IWL_MVM_QUEUE_SHARED: queue is shared, or in a process of becoming shared
709  *	This is a state in which a single queue serves more than one TID, all of
710  *	which are not aggregated. Note that the queue is only associated to one
711  *	RA.
712  */
713 enum iwl_mvm_queue_status {
714 	IWL_MVM_QUEUE_FREE,
715 	IWL_MVM_QUEUE_RESERVED,
716 	IWL_MVM_QUEUE_READY,
717 	IWL_MVM_QUEUE_SHARED,
718 };
719 
720 #define IWL_MVM_DQA_QUEUE_TIMEOUT	(5 * HZ)
721 #define IWL_MVM_INVALID_QUEUE		0xFFFF
722 
723 #define IWL_MVM_NUM_CIPHERS             10
724 
725 
726 struct iwl_mvm_txq {
727 	struct list_head list;
728 	u16 txq_id;
729 	atomic_t tx_request;
730 	bool stopped;
731 };
732 
733 static inline struct iwl_mvm_txq *
734 iwl_mvm_txq_from_mac80211(struct ieee80211_txq *txq)
735 {
736 	return (void *)txq->drv_priv;
737 }
738 
739 static inline struct iwl_mvm_txq *
740 iwl_mvm_txq_from_tid(struct ieee80211_sta *sta, u8 tid)
741 {
742 	if (tid == IWL_MAX_TID_COUNT)
743 		tid = IEEE80211_NUM_TIDS;
744 
745 	return (void *)sta->txq[tid]->drv_priv;
746 }
747 
748 /**
749  * struct iwl_mvm_tvqm_txq_info - maps TVQM hw queue to tid
750  *
751  * @sta_id: sta id
752  * @txq_tid: txq tid
753  */
754 struct iwl_mvm_tvqm_txq_info {
755 	u8 sta_id;
756 	u8 txq_tid;
757 };
758 
759 struct iwl_mvm_dqa_txq_info {
760 	u8 ra_sta_id; /* The RA this queue is mapped to, if exists */
761 	bool reserved; /* Is this the TXQ reserved for a STA */
762 	u8 mac80211_ac; /* The mac80211 AC this queue is mapped to */
763 	u8 txq_tid; /* The TID "owner" of this queue*/
764 	u16 tid_bitmap; /* Bitmap of the TIDs mapped to this queue */
765 	/* Timestamp for inactivation per TID of this queue */
766 	unsigned long last_frame_time[IWL_MAX_TID_COUNT + 1];
767 	enum iwl_mvm_queue_status status;
768 };
769 
770 struct iwl_mvm {
771 	/* for logger access */
772 	struct device *dev;
773 
774 	struct iwl_trans *trans;
775 	const struct iwl_fw *fw;
776 	const struct iwl_cfg *cfg;
777 	struct iwl_phy_db *phy_db;
778 	struct ieee80211_hw *hw;
779 
780 	/* for protecting access to iwl_mvm */
781 	struct mutex mutex;
782 	struct list_head async_handlers_list;
783 	spinlock_t async_handlers_lock;
784 	struct work_struct async_handlers_wk;
785 
786 	struct work_struct roc_done_wk;
787 
788 	unsigned long init_status;
789 
790 	unsigned long status;
791 
792 	u32 queue_sync_cookie;
793 	unsigned long queue_sync_state;
794 	/*
795 	 * for beacon filtering -
796 	 * currently only one interface can be supported
797 	 */
798 	struct iwl_mvm_vif *bf_allowed_vif;
799 
800 	bool hw_registered;
801 	bool rfkill_safe_init_done;
802 
803 	u8 cca_40mhz_workaround;
804 
805 	u32 ampdu_ref;
806 	bool ampdu_toggle;
807 
808 	struct iwl_notif_wait_data notif_wait;
809 
810 	union {
811 		struct mvm_statistics_rx_v3 rx_stats_v3;
812 		struct mvm_statistics_rx rx_stats;
813 	};
814 
815 	struct {
816 		u64 rx_time;
817 		u64 tx_time;
818 		u64 on_time_rf;
819 		u64 on_time_scan;
820 	} radio_stats, accu_radio_stats;
821 
822 	struct list_head add_stream_txqs;
823 	union {
824 		struct iwl_mvm_dqa_txq_info queue_info[IWL_MAX_HW_QUEUES];
825 		struct iwl_mvm_tvqm_txq_info tvqm_info[IWL_MAX_TVQM_QUEUES];
826 	};
827 	struct work_struct add_stream_wk; /* To add streams to queues */
828 
829 	const char *nvm_file_name;
830 	struct iwl_nvm_data *nvm_data;
831 	/* NVM sections */
832 	struct iwl_nvm_section nvm_sections[NVM_MAX_NUM_SECTIONS];
833 
834 	struct iwl_fw_runtime fwrt;
835 
836 	/* EEPROM MAC addresses */
837 	struct mac_address addresses[IWL_MVM_MAX_ADDRESSES];
838 
839 	/* data related to data path */
840 	struct iwl_rx_phy_info last_phy_info;
841 	struct ieee80211_sta __rcu *fw_id_to_mac_id[IWL_MVM_STATION_COUNT_MAX];
842 	u8 rx_ba_sessions;
843 
844 	/* configured by mac80211 */
845 	u32 rts_threshold;
846 
847 	/* Scan status, cmd (pre-allocated) and auxiliary station */
848 	unsigned int scan_status;
849 	void *scan_cmd;
850 	struct iwl_mcast_filter_cmd *mcast_filter_cmd;
851 	/* For CDB this is low band scan type, for non-CDB - type. */
852 	enum iwl_mvm_scan_type scan_type;
853 	enum iwl_mvm_scan_type hb_scan_type;
854 
855 	enum iwl_mvm_sched_scan_pass_all_states sched_scan_pass_all;
856 	struct delayed_work scan_timeout_dwork;
857 
858 	/* max number of simultaneous scans the FW supports */
859 	unsigned int max_scans;
860 
861 	/* UMAC scan tracking */
862 	u32 scan_uid_status[IWL_MVM_MAX_UMAC_SCANS];
863 
864 	/* start time of last scan in TSF of the mac that requested the scan */
865 	u64 scan_start;
866 
867 	/* the vif that requested the current scan */
868 	struct iwl_mvm_vif *scan_vif;
869 
870 	/* rx chain antennas set through debugfs for the scan command */
871 	u8 scan_rx_ant;
872 
873 #ifdef CONFIG_IWLWIFI_BCAST_FILTERING
874 	/* broadcast filters to configure for each associated station */
875 	const struct iwl_fw_bcast_filter *bcast_filters;
876 #ifdef CONFIG_IWLWIFI_DEBUGFS
877 	struct {
878 		bool override;
879 		struct iwl_bcast_filter_cmd cmd;
880 	} dbgfs_bcast_filtering;
881 #endif
882 #endif
883 
884 	/* Internal station */
885 	struct iwl_mvm_int_sta aux_sta;
886 	struct iwl_mvm_int_sta snif_sta;
887 
888 	bool last_ebs_successful;
889 
890 	u8 scan_last_antenna_idx; /* to toggle TX between antennas */
891 	u8 mgmt_last_antenna_idx;
892 
893 	/* last smart fifo state that was successfully sent to firmware */
894 	enum iwl_sf_state sf_state;
895 
896 	/*
897 	 * Leave this pointer outside the ifdef below so that it can be
898 	 * assigned without ifdef in the source code.
899 	 */
900 	struct dentry *debugfs_dir;
901 #ifdef CONFIG_IWLWIFI_DEBUGFS
902 	u32 dbgfs_sram_offset, dbgfs_sram_len;
903 	u32 dbgfs_prph_reg_addr;
904 	bool disable_power_off;
905 	bool disable_power_off_d3;
906 	bool beacon_inject_active;
907 
908 	bool scan_iter_notif_enabled;
909 
910 	struct debugfs_blob_wrapper nvm_hw_blob;
911 	struct debugfs_blob_wrapper nvm_sw_blob;
912 	struct debugfs_blob_wrapper nvm_calib_blob;
913 	struct debugfs_blob_wrapper nvm_prod_blob;
914 	struct debugfs_blob_wrapper nvm_phy_sku_blob;
915 	struct debugfs_blob_wrapper nvm_reg_blob;
916 
917 	struct iwl_mvm_frame_stats drv_rx_stats;
918 	spinlock_t drv_stats_lock;
919 	u16 dbgfs_rx_phyinfo;
920 #endif
921 
922 	struct iwl_mvm_phy_ctxt phy_ctxts[NUM_PHY_CTX];
923 
924 	struct list_head time_event_list;
925 	spinlock_t time_event_lock;
926 
927 	/*
928 	 * A bitmap indicating the index of the key in use. The firmware
929 	 * can hold 16 keys at most. Reflect this fact.
930 	 */
931 	unsigned long fw_key_table[BITS_TO_LONGS(STA_KEY_MAX_NUM)];
932 	u8 fw_key_deleted[STA_KEY_MAX_NUM];
933 
934 	u8 vif_count;
935 	struct ieee80211_vif __rcu *vif_id_to_mac[NUM_MAC_INDEX_DRIVER];
936 
937 	/* -1 for always, 0 for never, >0 for that many times */
938 	s8 fw_restart;
939 	u8 *error_recovery_buf;
940 
941 #ifdef CONFIG_IWLWIFI_LEDS
942 	struct led_classdev led;
943 #endif
944 
945 	struct ieee80211_vif *p2p_device_vif;
946 
947 #ifdef CONFIG_PM
948 	struct wiphy_wowlan_support wowlan;
949 	int gtk_ivlen, gtk_icvlen, ptk_ivlen, ptk_icvlen;
950 
951 	/* sched scan settings for net detect */
952 	struct ieee80211_scan_ies nd_ies;
953 	struct cfg80211_match_set *nd_match_sets;
954 	int n_nd_match_sets;
955 	struct ieee80211_channel **nd_channels;
956 	int n_nd_channels;
957 	bool net_detect;
958 	u8 offload_tid;
959 #ifdef CONFIG_IWLWIFI_DEBUGFS
960 	bool d3_wake_sysassert;
961 	bool d3_test_active;
962 	u32 d3_test_pme_ptr;
963 	struct ieee80211_vif *keep_vif;
964 	u32 last_netdetect_scans; /* no. of scans in the last net-detect wake */
965 #endif
966 #endif
967 
968 	wait_queue_head_t rx_sync_waitq;
969 
970 	/* BT-Coex */
971 	struct iwl_bt_coex_profile_notif last_bt_notif;
972 	struct iwl_bt_coex_ci_cmd last_bt_ci_cmd;
973 
974 	u8 bt_tx_prio;
975 	enum iwl_bt_force_ant_mode bt_force_ant_mode;
976 
977 	/* Aux ROC */
978 	struct list_head aux_roc_te_list;
979 
980 	/* Thermal Throttling and CTkill */
981 	struct iwl_mvm_tt_mgmt thermal_throttle;
982 #ifdef CONFIG_THERMAL
983 	struct iwl_mvm_thermal_device tz_device;
984 	struct iwl_mvm_cooling_device cooling_dev;
985 #endif
986 
987 	s32 temperature;	/* Celsius */
988 	/*
989 	 * Debug option to set the NIC temperature. This option makes the
990 	 * driver think this is the actual NIC temperature, and ignore the
991 	 * real temperature that is received from the fw
992 	 */
993 	bool temperature_test;  /* Debug test temperature is enabled */
994 
995 	unsigned long bt_coex_last_tcm_ts;
996 	struct iwl_mvm_tcm tcm;
997 
998 	u8 uapsd_noagg_bssid_write_idx;
999 	struct mac_address uapsd_noagg_bssids[IWL_MVM_UAPSD_NOAGG_BSSIDS_NUM]
1000 		__aligned(2);
1001 
1002 	struct iwl_time_quota_cmd last_quota_cmd;
1003 
1004 #ifdef CONFIG_NL80211_TESTMODE
1005 	u32 noa_duration;
1006 	struct ieee80211_vif *noa_vif;
1007 #endif
1008 
1009 	/* Tx queues */
1010 	u16 aux_queue;
1011 	u16 snif_queue;
1012 	u16 probe_queue;
1013 	u16 p2p_dev_queue;
1014 
1015 	/* Indicate if device power save is allowed */
1016 	u8 ps_disabled; /* u8 instead of bool to ease debugfs_create_* usage */
1017 	/* Indicate if 32Khz external clock is valid */
1018 	u32 ext_clock_valid;
1019 
1020 	struct ieee80211_vif __rcu *csa_vif;
1021 	struct ieee80211_vif __rcu *csa_tx_blocked_vif;
1022 	u8 csa_tx_block_bcn_timeout;
1023 
1024 	/* system time of last beacon (for AP/GO interface) */
1025 	u32 ap_last_beacon_gp2;
1026 
1027 	/* indicates that we transmitted the last beacon */
1028 	bool ibss_manager;
1029 
1030 	bool lar_regdom_set;
1031 	enum iwl_mcc_source mcc_src;
1032 
1033 	/* TDLS channel switch data */
1034 	struct {
1035 		struct delayed_work dwork;
1036 		enum iwl_mvm_tdls_cs_state state;
1037 
1038 		/*
1039 		 * Current cs sta - might be different from periodic cs peer
1040 		 * station. Value is meaningless when the cs-state is idle.
1041 		 */
1042 		u8 cur_sta_id;
1043 
1044 		/* TDLS periodic channel-switch peer */
1045 		struct {
1046 			u8 sta_id;
1047 			u8 op_class;
1048 			bool initiator; /* are we the link initiator */
1049 			struct cfg80211_chan_def chandef;
1050 			struct sk_buff *skb; /* ch sw template */
1051 			u32 ch_sw_tm_ie;
1052 
1053 			/* timestamp of last ch-sw request sent (GP2 time) */
1054 			u32 sent_timestamp;
1055 		} peer;
1056 	} tdls_cs;
1057 
1058 
1059 	u32 ciphers[IWL_MVM_NUM_CIPHERS];
1060 	struct ieee80211_cipher_scheme cs[IWL_UCODE_MAX_CS];
1061 
1062 	struct cfg80211_ftm_responder_stats ftm_resp_stats;
1063 	struct {
1064 		struct cfg80211_pmsr_request *req;
1065 		struct wireless_dev *req_wdev;
1066 		struct list_head loc_list;
1067 		int responses[IWL_MVM_TOF_MAX_APS];
1068 		struct {
1069 			struct list_head resp;
1070 		} smooth;
1071 		struct list_head pasn_list;
1072 	} ftm_initiator;
1073 
1074 	struct list_head resp_pasn_list;
1075 
1076 	struct {
1077 		u8 d0i3_resp;
1078 		u8 range_resp;
1079 	} cmd_ver;
1080 
1081 	struct ieee80211_vif *nan_vif;
1082 #define IWL_MAX_BAID	32
1083 	struct iwl_mvm_baid_data __rcu *baid_map[IWL_MAX_BAID];
1084 
1085 	/*
1086 	 * Drop beacons from other APs in AP mode when there are no connected
1087 	 * clients.
1088 	 */
1089 	bool drop_bcn_ap_mode;
1090 
1091 	struct delayed_work cs_tx_unblock_dwork;
1092 
1093 	/* does a monitor vif exist (only one can exist hence bool) */
1094 	bool monitor_on;
1095 
1096 	/* sniffer data to include in radiotap */
1097 	__le16 cur_aid;
1098 	u8 cur_bssid[ETH_ALEN];
1099 };
1100 
1101 /* Extract MVM priv from op_mode and _hw */
1102 #define IWL_OP_MODE_GET_MVM(_iwl_op_mode)		\
1103 	((struct iwl_mvm *)(_iwl_op_mode)->op_mode_specific)
1104 
1105 #define IWL_MAC80211_GET_MVM(_hw)			\
1106 	IWL_OP_MODE_GET_MVM((struct iwl_op_mode *)((_hw)->priv))
1107 
1108 /**
1109  * enum iwl_mvm_status - MVM status bits
1110  * @IWL_MVM_STATUS_HW_RFKILL: HW RF-kill is asserted
1111  * @IWL_MVM_STATUS_HW_CTKILL: CT-kill is active
1112  * @IWL_MVM_STATUS_ROC_RUNNING: remain-on-channel is running
1113  * @IWL_MVM_STATUS_HW_RESTART_REQUESTED: HW restart was requested
1114  * @IWL_MVM_STATUS_IN_HW_RESTART: HW restart is active
1115  * @IWL_MVM_STATUS_ROC_AUX_RUNNING: AUX remain-on-channel is running
1116  * @IWL_MVM_STATUS_FIRMWARE_RUNNING: firmware is running
1117  * @IWL_MVM_STATUS_NEED_FLUSH_P2P: need to flush P2P bcast STA
1118  * @IWL_MVM_STATUS_IN_D3: in D3 (or at least about to go into it)
1119  */
1120 enum iwl_mvm_status {
1121 	IWL_MVM_STATUS_HW_RFKILL,
1122 	IWL_MVM_STATUS_HW_CTKILL,
1123 	IWL_MVM_STATUS_ROC_RUNNING,
1124 	IWL_MVM_STATUS_HW_RESTART_REQUESTED,
1125 	IWL_MVM_STATUS_IN_HW_RESTART,
1126 	IWL_MVM_STATUS_ROC_AUX_RUNNING,
1127 	IWL_MVM_STATUS_FIRMWARE_RUNNING,
1128 	IWL_MVM_STATUS_NEED_FLUSH_P2P,
1129 	IWL_MVM_STATUS_IN_D3,
1130 };
1131 
1132 /* Keep track of completed init configuration */
1133 enum iwl_mvm_init_status {
1134 	IWL_MVM_INIT_STATUS_THERMAL_INIT_COMPLETE = BIT(0),
1135 	IWL_MVM_INIT_STATUS_LEDS_INIT_COMPLETE = BIT(1),
1136 };
1137 
1138 static inline bool iwl_mvm_is_radio_killed(struct iwl_mvm *mvm)
1139 {
1140 	return test_bit(IWL_MVM_STATUS_HW_RFKILL, &mvm->status) ||
1141 	       test_bit(IWL_MVM_STATUS_HW_CTKILL, &mvm->status);
1142 }
1143 
1144 static inline bool iwl_mvm_is_radio_hw_killed(struct iwl_mvm *mvm)
1145 {
1146 	return test_bit(IWL_MVM_STATUS_HW_RFKILL, &mvm->status);
1147 }
1148 
1149 static inline bool iwl_mvm_firmware_running(struct iwl_mvm *mvm)
1150 {
1151 	return test_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING, &mvm->status);
1152 }
1153 
1154 /* Must be called with rcu_read_lock() held and it can only be
1155  * released when mvmsta is not needed anymore.
1156  */
1157 static inline struct iwl_mvm_sta *
1158 iwl_mvm_sta_from_staid_rcu(struct iwl_mvm *mvm, u8 sta_id)
1159 {
1160 	struct ieee80211_sta *sta;
1161 
1162 	if (sta_id >= mvm->fw->ucode_capa.num_stations)
1163 		return NULL;
1164 
1165 	sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
1166 
1167 	/* This can happen if the station has been removed right now */
1168 	if (IS_ERR_OR_NULL(sta))
1169 		return NULL;
1170 
1171 	return iwl_mvm_sta_from_mac80211(sta);
1172 }
1173 
1174 static inline struct iwl_mvm_sta *
1175 iwl_mvm_sta_from_staid_protected(struct iwl_mvm *mvm, u8 sta_id)
1176 {
1177 	struct ieee80211_sta *sta;
1178 
1179 	if (sta_id >= mvm->fw->ucode_capa.num_stations)
1180 		return NULL;
1181 
1182 	sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
1183 					lockdep_is_held(&mvm->mutex));
1184 
1185 	/* This can happen if the station has been removed right now */
1186 	if (IS_ERR_OR_NULL(sta))
1187 		return NULL;
1188 
1189 	return iwl_mvm_sta_from_mac80211(sta);
1190 }
1191 
1192 static inline struct ieee80211_vif *
1193 iwl_mvm_rcu_dereference_vif_id(struct iwl_mvm *mvm, u8 vif_id, bool rcu)
1194 {
1195 	if (WARN_ON(vif_id >= ARRAY_SIZE(mvm->vif_id_to_mac)))
1196 		return NULL;
1197 
1198 	if (rcu)
1199 		return rcu_dereference(mvm->vif_id_to_mac[vif_id]);
1200 
1201 	return rcu_dereference_protected(mvm->vif_id_to_mac[vif_id],
1202 					 lockdep_is_held(&mvm->mutex));
1203 }
1204 
1205 static inline bool iwl_mvm_is_adaptive_dwell_supported(struct iwl_mvm *mvm)
1206 {
1207 	return fw_has_api(&mvm->fw->ucode_capa,
1208 			  IWL_UCODE_TLV_API_ADAPTIVE_DWELL);
1209 }
1210 
1211 static inline bool iwl_mvm_is_adaptive_dwell_v2_supported(struct iwl_mvm *mvm)
1212 {
1213 	return fw_has_api(&mvm->fw->ucode_capa,
1214 			  IWL_UCODE_TLV_API_ADAPTIVE_DWELL_V2);
1215 }
1216 
1217 static inline bool iwl_mvm_is_adwell_hb_ap_num_supported(struct iwl_mvm *mvm)
1218 {
1219 	return fw_has_api(&mvm->fw->ucode_capa,
1220 			  IWL_UCODE_TLV_API_ADWELL_HB_DEF_N_AP);
1221 }
1222 
1223 static inline bool iwl_mvm_is_oce_supported(struct iwl_mvm *mvm)
1224 {
1225 	/* OCE should never be enabled for LMAC scan FWs */
1226 	return fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_OCE);
1227 }
1228 
1229 static inline bool iwl_mvm_is_frag_ebs_supported(struct iwl_mvm *mvm)
1230 {
1231 	return fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_FRAG_EBS);
1232 }
1233 
1234 static inline bool iwl_mvm_is_short_beacon_notif_supported(struct iwl_mvm *mvm)
1235 {
1236 	return fw_has_api(&mvm->fw->ucode_capa,
1237 			  IWL_UCODE_TLV_API_SHORT_BEACON_NOTIF);
1238 }
1239 
1240 static inline bool iwl_mvm_is_dqa_data_queue(struct iwl_mvm *mvm, u8 queue)
1241 {
1242 	return (queue >= IWL_MVM_DQA_MIN_DATA_QUEUE) &&
1243 	       (queue <= IWL_MVM_DQA_MAX_DATA_QUEUE);
1244 }
1245 
1246 static inline bool iwl_mvm_is_dqa_mgmt_queue(struct iwl_mvm *mvm, u8 queue)
1247 {
1248 	return (queue >= IWL_MVM_DQA_MIN_MGMT_QUEUE) &&
1249 	       (queue <= IWL_MVM_DQA_MAX_MGMT_QUEUE);
1250 }
1251 
1252 static inline bool iwl_mvm_is_lar_supported(struct iwl_mvm *mvm)
1253 {
1254 	bool nvm_lar = mvm->nvm_data->lar_enabled;
1255 	bool tlv_lar = fw_has_capa(&mvm->fw->ucode_capa,
1256 				   IWL_UCODE_TLV_CAPA_LAR_SUPPORT);
1257 
1258 	/*
1259 	 * Enable LAR only if it is supported by the FW (TLV) &&
1260 	 * enabled in the NVM
1261 	 */
1262 	if (mvm->cfg->nvm_type == IWL_NVM_EXT)
1263 		return nvm_lar && tlv_lar;
1264 	else
1265 		return tlv_lar;
1266 }
1267 
1268 static inline bool iwl_mvm_is_wifi_mcc_supported(struct iwl_mvm *mvm)
1269 {
1270 	return fw_has_api(&mvm->fw->ucode_capa,
1271 			  IWL_UCODE_TLV_API_WIFI_MCC_UPDATE) ||
1272 	       fw_has_capa(&mvm->fw->ucode_capa,
1273 			   IWL_UCODE_TLV_CAPA_LAR_MULTI_MCC);
1274 }
1275 
1276 static inline bool iwl_mvm_bt_is_rrc_supported(struct iwl_mvm *mvm)
1277 {
1278 	return fw_has_capa(&mvm->fw->ucode_capa,
1279 			   IWL_UCODE_TLV_CAPA_BT_COEX_RRC) &&
1280 		IWL_MVM_BT_COEX_RRC;
1281 }
1282 
1283 static inline bool iwl_mvm_is_csum_supported(struct iwl_mvm *mvm)
1284 {
1285 	return fw_has_capa(&mvm->fw->ucode_capa,
1286 			   IWL_UCODE_TLV_CAPA_CSUM_SUPPORT) &&
1287                !IWL_MVM_HW_CSUM_DISABLE;
1288 }
1289 
1290 static inline bool iwl_mvm_is_mplut_supported(struct iwl_mvm *mvm)
1291 {
1292 	return fw_has_capa(&mvm->fw->ucode_capa,
1293 			   IWL_UCODE_TLV_CAPA_BT_MPLUT_SUPPORT) &&
1294 		IWL_MVM_BT_COEX_MPLUT;
1295 }
1296 
1297 static inline
1298 bool iwl_mvm_is_p2p_scm_uapsd_supported(struct iwl_mvm *mvm)
1299 {
1300 	return fw_has_capa(&mvm->fw->ucode_capa,
1301 			   IWL_UCODE_TLV_CAPA_P2P_SCM_UAPSD) &&
1302 		!(iwlwifi_mod_params.uapsd_disable &
1303 		  IWL_DISABLE_UAPSD_P2P_CLIENT);
1304 }
1305 
1306 static inline bool iwl_mvm_has_new_rx_api(struct iwl_mvm *mvm)
1307 {
1308 	return fw_has_capa(&mvm->fw->ucode_capa,
1309 			   IWL_UCODE_TLV_CAPA_MULTI_QUEUE_RX_SUPPORT);
1310 }
1311 
1312 static inline bool iwl_mvm_has_new_tx_api(struct iwl_mvm *mvm)
1313 {
1314 	/* TODO - replace with TLV once defined */
1315 	return mvm->trans->trans_cfg->use_tfh;
1316 }
1317 
1318 static inline bool iwl_mvm_has_unified_ucode(struct iwl_mvm *mvm)
1319 {
1320 	/* TODO - better define this */
1321 	return mvm->trans->trans_cfg->device_family >= IWL_DEVICE_FAMILY_22000;
1322 }
1323 
1324 static inline bool iwl_mvm_is_cdb_supported(struct iwl_mvm *mvm)
1325 {
1326 	/*
1327 	 * TODO:
1328 	 * The issue of how to determine CDB APIs and usage is still not fully
1329 	 * defined.
1330 	 * There is a compilation for CDB and non-CDB FW, but there may
1331 	 * be also runtime check.
1332 	 * For now there is a TLV for checking compilation mode, but a
1333 	 * runtime check will also have to be here - once defined.
1334 	 */
1335 	return fw_has_capa(&mvm->fw->ucode_capa,
1336 			   IWL_UCODE_TLV_CAPA_CDB_SUPPORT);
1337 }
1338 
1339 static inline bool iwl_mvm_cdb_scan_api(struct iwl_mvm *mvm)
1340 {
1341 	/*
1342 	 * TODO: should this be the same as iwl_mvm_is_cdb_supported()?
1343 	 * but then there's a little bit of code in scan that won't make
1344 	 * any sense...
1345 	 */
1346 	return mvm->trans->trans_cfg->device_family >= IWL_DEVICE_FAMILY_22000;
1347 }
1348 
1349 static inline bool iwl_mvm_is_scan_ext_chan_supported(struct iwl_mvm *mvm)
1350 {
1351 	return fw_has_api(&mvm->fw->ucode_capa,
1352 			  IWL_UCODE_TLV_API_SCAN_EXT_CHAN_VER);
1353 }
1354 
1355 
1356 static inline bool iwl_mvm_is_reduced_config_scan_supported(struct iwl_mvm *mvm)
1357 {
1358 	return fw_has_api(&mvm->fw->ucode_capa,
1359 			  IWL_UCODE_TLV_API_REDUCED_SCAN_CONFIG);
1360 }
1361 
1362 static inline bool iwl_mvm_is_band_in_rx_supported(struct iwl_mvm *mvm)
1363 {
1364 	return fw_has_api(&mvm->fw->ucode_capa,
1365 			   IWL_UCODE_TLV_API_BAND_IN_RX_DATA);
1366 }
1367 
1368 static inline bool iwl_mvm_has_new_rx_stats_api(struct iwl_mvm *mvm)
1369 {
1370 	return fw_has_api(&mvm->fw->ucode_capa,
1371 			  IWL_UCODE_TLV_API_NEW_RX_STATS);
1372 }
1373 
1374 static inline bool iwl_mvm_has_quota_low_latency(struct iwl_mvm *mvm)
1375 {
1376 	return fw_has_api(&mvm->fw->ucode_capa,
1377 			  IWL_UCODE_TLV_API_QUOTA_LOW_LATENCY);
1378 }
1379 
1380 static inline bool iwl_mvm_has_tlc_offload(const struct iwl_mvm *mvm)
1381 {
1382 	return fw_has_capa(&mvm->fw->ucode_capa,
1383 			   IWL_UCODE_TLV_CAPA_TLC_OFFLOAD);
1384 }
1385 
1386 static inline struct agg_tx_status *
1387 iwl_mvm_get_agg_status(struct iwl_mvm *mvm, void *tx_resp)
1388 {
1389 	if (iwl_mvm_has_new_tx_api(mvm))
1390 		return &((struct iwl_mvm_tx_resp *)tx_resp)->status;
1391 	else
1392 		return ((struct iwl_mvm_tx_resp_v3 *)tx_resp)->status;
1393 }
1394 
1395 static inline bool iwl_mvm_is_tt_in_fw(struct iwl_mvm *mvm)
1396 {
1397 	/* these two TLV are redundant since the responsibility to CT-kill by
1398 	 * FW happens only after we send at least one command of
1399 	 * temperature THs report.
1400 	 */
1401 	return fw_has_capa(&mvm->fw->ucode_capa,
1402 			   IWL_UCODE_TLV_CAPA_CT_KILL_BY_FW) &&
1403 	       fw_has_capa(&mvm->fw->ucode_capa,
1404 			   IWL_UCODE_TLV_CAPA_TEMP_THS_REPORT_SUPPORT);
1405 }
1406 
1407 static inline bool iwl_mvm_is_ctdp_supported(struct iwl_mvm *mvm)
1408 {
1409 	return fw_has_capa(&mvm->fw->ucode_capa,
1410 			   IWL_UCODE_TLV_CAPA_CTDP_SUPPORT);
1411 }
1412 
1413 extern const u8 iwl_mvm_ac_to_tx_fifo[];
1414 extern const u8 iwl_mvm_ac_to_gen2_tx_fifo[];
1415 
1416 static inline u8 iwl_mvm_mac_ac_to_tx_fifo(struct iwl_mvm *mvm,
1417 					   enum ieee80211_ac_numbers ac)
1418 {
1419 	return iwl_mvm_has_new_tx_api(mvm) ?
1420 		iwl_mvm_ac_to_gen2_tx_fifo[ac] : iwl_mvm_ac_to_tx_fifo[ac];
1421 }
1422 
1423 struct iwl_rate_info {
1424 	u8 plcp;	/* uCode API:  IWL_RATE_6M_PLCP, etc. */
1425 	u8 plcp_siso;	/* uCode API:  IWL_RATE_SISO_6M_PLCP, etc. */
1426 	u8 plcp_mimo2;	/* uCode API:  IWL_RATE_MIMO2_6M_PLCP, etc. */
1427 	u8 plcp_mimo3;  /* uCode API:  IWL_RATE_MIMO3_6M_PLCP, etc. */
1428 	u8 ieee;	/* MAC header:  IWL_RATE_6M_IEEE, etc. */
1429 };
1430 
1431 void __iwl_mvm_mac_stop(struct iwl_mvm *mvm);
1432 int __iwl_mvm_mac_start(struct iwl_mvm *mvm);
1433 
1434 /******************
1435  * MVM Methods
1436  ******************/
1437 /* uCode */
1438 int iwl_run_init_mvm_ucode(struct iwl_mvm *mvm);
1439 
1440 /* Utils */
1441 int iwl_mvm_legacy_rate_to_mac80211_idx(u32 rate_n_flags,
1442 					enum nl80211_band band);
1443 void iwl_mvm_hwrate_to_tx_rate(u32 rate_n_flags,
1444 			       enum nl80211_band band,
1445 			       struct ieee80211_tx_rate *r);
1446 u8 iwl_mvm_mac80211_idx_to_hwrate(int rate_idx);
1447 u8 iwl_mvm_mac80211_ac_to_ucode_ac(enum ieee80211_ac_numbers ac);
1448 void iwl_mvm_dump_nic_error_log(struct iwl_mvm *mvm);
1449 u8 first_antenna(u8 mask);
1450 u8 iwl_mvm_next_antenna(struct iwl_mvm *mvm, u8 valid, u8 last_idx);
1451 void iwl_mvm_get_sync_time(struct iwl_mvm *mvm, u32 *gp2, u64 *boottime);
1452 u32 iwl_mvm_get_systime(struct iwl_mvm *mvm);
1453 
1454 /* Tx / Host Commands */
1455 int __must_check iwl_mvm_send_cmd(struct iwl_mvm *mvm,
1456 				  struct iwl_host_cmd *cmd);
1457 int __must_check iwl_mvm_send_cmd_pdu(struct iwl_mvm *mvm, u32 id,
1458 				      u32 flags, u16 len, const void *data);
1459 int __must_check iwl_mvm_send_cmd_status(struct iwl_mvm *mvm,
1460 					 struct iwl_host_cmd *cmd,
1461 					 u32 *status);
1462 int __must_check iwl_mvm_send_cmd_pdu_status(struct iwl_mvm *mvm, u32 id,
1463 					     u16 len, const void *data,
1464 					     u32 *status);
1465 int iwl_mvm_tx_skb_sta(struct iwl_mvm *mvm, struct sk_buff *skb,
1466 		       struct ieee80211_sta *sta);
1467 int iwl_mvm_tx_skb_non_sta(struct iwl_mvm *mvm, struct sk_buff *skb);
1468 void iwl_mvm_set_tx_cmd(struct iwl_mvm *mvm, struct sk_buff *skb,
1469 			struct iwl_tx_cmd *tx_cmd,
1470 			struct ieee80211_tx_info *info, u8 sta_id);
1471 void iwl_mvm_set_tx_cmd_rate(struct iwl_mvm *mvm, struct iwl_tx_cmd *tx_cmd,
1472 			    struct ieee80211_tx_info *info,
1473 			    struct ieee80211_sta *sta, __le16 fc);
1474 void iwl_mvm_mac_itxq_xmit(struct ieee80211_hw *hw, struct ieee80211_txq *txq);
1475 unsigned int iwl_mvm_max_amsdu_size(struct iwl_mvm *mvm,
1476 				    struct ieee80211_sta *sta,
1477 				    unsigned int tid);
1478 
1479 #ifdef CONFIG_IWLWIFI_DEBUG
1480 const char *iwl_mvm_get_tx_fail_reason(u32 status);
1481 #else
1482 static inline const char *iwl_mvm_get_tx_fail_reason(u32 status) { return ""; }
1483 #endif
1484 int iwl_mvm_flush_tx_path(struct iwl_mvm *mvm, u32 tfd_msk);
1485 int iwl_mvm_flush_sta(struct iwl_mvm *mvm, void *sta, bool internal);
1486 int iwl_mvm_flush_sta_tids(struct iwl_mvm *mvm, u32 sta_id, u16 tids);
1487 
1488 void iwl_mvm_async_handlers_purge(struct iwl_mvm *mvm);
1489 
1490 static inline void iwl_mvm_set_tx_cmd_ccmp(struct ieee80211_tx_info *info,
1491 					   struct iwl_tx_cmd *tx_cmd)
1492 {
1493 	struct ieee80211_key_conf *keyconf = info->control.hw_key;
1494 
1495 	tx_cmd->sec_ctl = TX_CMD_SEC_CCM;
1496 	memcpy(tx_cmd->key, keyconf->key, keyconf->keylen);
1497 }
1498 
1499 static inline void iwl_mvm_wait_for_async_handlers(struct iwl_mvm *mvm)
1500 {
1501 	flush_work(&mvm->async_handlers_wk);
1502 }
1503 
1504 /* Statistics */
1505 void iwl_mvm_handle_rx_statistics(struct iwl_mvm *mvm,
1506 				  struct iwl_rx_packet *pkt);
1507 void iwl_mvm_rx_statistics(struct iwl_mvm *mvm,
1508 			   struct iwl_rx_cmd_buffer *rxb);
1509 int iwl_mvm_request_statistics(struct iwl_mvm *mvm, bool clear);
1510 void iwl_mvm_accu_radio_stats(struct iwl_mvm *mvm);
1511 
1512 /* NVM */
1513 int iwl_nvm_init(struct iwl_mvm *mvm);
1514 int iwl_mvm_load_nvm_to_nic(struct iwl_mvm *mvm);
1515 
1516 static inline u8 iwl_mvm_get_valid_tx_ant(struct iwl_mvm *mvm)
1517 {
1518 	return mvm->nvm_data && mvm->nvm_data->valid_tx_ant ?
1519 	       mvm->fw->valid_tx_ant & mvm->nvm_data->valid_tx_ant :
1520 	       mvm->fw->valid_tx_ant;
1521 }
1522 
1523 static inline u8 iwl_mvm_get_valid_rx_ant(struct iwl_mvm *mvm)
1524 {
1525 	return mvm->nvm_data && mvm->nvm_data->valid_rx_ant ?
1526 	       mvm->fw->valid_rx_ant & mvm->nvm_data->valid_rx_ant :
1527 	       mvm->fw->valid_rx_ant;
1528 }
1529 
1530 static inline void iwl_mvm_toggle_tx_ant(struct iwl_mvm *mvm, u8 *ant)
1531 {
1532 	*ant = iwl_mvm_next_antenna(mvm, iwl_mvm_get_valid_tx_ant(mvm), *ant);
1533 }
1534 
1535 static inline u32 iwl_mvm_get_phy_config(struct iwl_mvm *mvm)
1536 {
1537 	u32 phy_config = ~(FW_PHY_CFG_TX_CHAIN |
1538 			   FW_PHY_CFG_RX_CHAIN);
1539 	u32 valid_rx_ant = iwl_mvm_get_valid_rx_ant(mvm);
1540 	u32 valid_tx_ant = iwl_mvm_get_valid_tx_ant(mvm);
1541 
1542 	phy_config |= valid_tx_ant << FW_PHY_CFG_TX_CHAIN_POS |
1543 		      valid_rx_ant << FW_PHY_CFG_RX_CHAIN_POS;
1544 
1545 	return mvm->fw->phy_config & phy_config;
1546 }
1547 
1548 int iwl_mvm_up(struct iwl_mvm *mvm);
1549 int iwl_mvm_load_d3_fw(struct iwl_mvm *mvm);
1550 
1551 int iwl_mvm_mac_setup_register(struct iwl_mvm *mvm);
1552 bool iwl_mvm_bcast_filter_build_cmd(struct iwl_mvm *mvm,
1553 				    struct iwl_bcast_filter_cmd *cmd);
1554 
1555 /*
1556  * FW notifications / CMD responses handlers
1557  * Convention: iwl_mvm_rx_<NAME OF THE CMD>
1558  */
1559 void iwl_mvm_rx_mq(struct iwl_op_mode *op_mode,
1560 		   struct napi_struct *napi,
1561 		   struct iwl_rx_cmd_buffer *rxb);
1562 void iwl_mvm_rx_rx_phy_cmd(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb);
1563 void iwl_mvm_rx_rx_mpdu(struct iwl_mvm *mvm, struct napi_struct *napi,
1564 			struct iwl_rx_cmd_buffer *rxb);
1565 void iwl_mvm_rx_mpdu_mq(struct iwl_mvm *mvm, struct napi_struct *napi,
1566 			struct iwl_rx_cmd_buffer *rxb, int queue);
1567 void iwl_mvm_rx_monitor_no_data(struct iwl_mvm *mvm, struct napi_struct *napi,
1568 				struct iwl_rx_cmd_buffer *rxb, int queue);
1569 void iwl_mvm_rx_frame_release(struct iwl_mvm *mvm, struct napi_struct *napi,
1570 			      struct iwl_rx_cmd_buffer *rxb, int queue);
1571 void iwl_mvm_rx_bar_frame_release(struct iwl_mvm *mvm, struct napi_struct *napi,
1572 				  struct iwl_rx_cmd_buffer *rxb, int queue);
1573 int iwl_mvm_notify_rx_queue(struct iwl_mvm *mvm, u32 rxq_mask,
1574 			    const struct iwl_mvm_internal_rxq_notif *notif,
1575 			    u32 notif_size, bool async);
1576 void iwl_mvm_rx_queue_notif(struct iwl_mvm *mvm, struct napi_struct *napi,
1577 			    struct iwl_rx_cmd_buffer *rxb, int queue);
1578 void iwl_mvm_rx_tx_cmd(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb);
1579 void iwl_mvm_mfu_assert_dump_notif(struct iwl_mvm *mvm,
1580 				   struct iwl_rx_cmd_buffer *rxb);
1581 void iwl_mvm_send_recovery_cmd(struct iwl_mvm *mvm, u32 flags);
1582 void iwl_mvm_rx_ba_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb);
1583 void iwl_mvm_rx_ant_coupling_notif(struct iwl_mvm *mvm,
1584 				   struct iwl_rx_cmd_buffer *rxb);
1585 void iwl_mvm_rx_fw_error(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb);
1586 void iwl_mvm_rx_card_state_notif(struct iwl_mvm *mvm,
1587 				 struct iwl_rx_cmd_buffer *rxb);
1588 void iwl_mvm_rx_mfuart_notif(struct iwl_mvm *mvm,
1589 			     struct iwl_rx_cmd_buffer *rxb);
1590 void iwl_mvm_rx_shared_mem_cfg_notif(struct iwl_mvm *mvm,
1591 				     struct iwl_rx_cmd_buffer *rxb);
1592 
1593 /* MVM PHY */
1594 int iwl_mvm_phy_ctxt_add(struct iwl_mvm *mvm, struct iwl_mvm_phy_ctxt *ctxt,
1595 			 struct cfg80211_chan_def *chandef,
1596 			 u8 chains_static, u8 chains_dynamic);
1597 int iwl_mvm_phy_ctxt_changed(struct iwl_mvm *mvm, struct iwl_mvm_phy_ctxt *ctxt,
1598 			     struct cfg80211_chan_def *chandef,
1599 			     u8 chains_static, u8 chains_dynamic);
1600 void iwl_mvm_phy_ctxt_ref(struct iwl_mvm *mvm,
1601 			  struct iwl_mvm_phy_ctxt *ctxt);
1602 void iwl_mvm_phy_ctxt_unref(struct iwl_mvm *mvm,
1603 			    struct iwl_mvm_phy_ctxt *ctxt);
1604 int iwl_mvm_phy_ctx_count(struct iwl_mvm *mvm);
1605 u8 iwl_mvm_get_channel_width(struct cfg80211_chan_def *chandef);
1606 u8 iwl_mvm_get_ctrl_pos(struct cfg80211_chan_def *chandef);
1607 
1608 /* MAC (virtual interface) programming */
1609 int iwl_mvm_mac_ctxt_init(struct iwl_mvm *mvm, struct ieee80211_vif *vif);
1610 int iwl_mvm_mac_ctxt_add(struct iwl_mvm *mvm, struct ieee80211_vif *vif);
1611 int iwl_mvm_mac_ctxt_changed(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1612 			     bool force_assoc_off, const u8 *bssid_override);
1613 int iwl_mvm_mac_ctxt_remove(struct iwl_mvm *mvm, struct ieee80211_vif *vif);
1614 int iwl_mvm_mac_ctxt_beacon_changed(struct iwl_mvm *mvm,
1615 				    struct ieee80211_vif *vif);
1616 int iwl_mvm_mac_ctxt_send_beacon(struct iwl_mvm *mvm,
1617 				 struct ieee80211_vif *vif,
1618 				 struct sk_buff *beacon);
1619 int iwl_mvm_mac_ctxt_send_beacon_cmd(struct iwl_mvm *mvm,
1620 				     struct sk_buff *beacon,
1621 				     void *data, int len);
1622 u8 iwl_mvm_mac_ctxt_get_lowest_rate(struct ieee80211_tx_info *info,
1623 				    struct ieee80211_vif *vif);
1624 void iwl_mvm_mac_ctxt_set_tim(struct iwl_mvm *mvm,
1625 			      __le32 *tim_index, __le32 *tim_size,
1626 			      u8 *beacon, u32 frame_size);
1627 void iwl_mvm_rx_beacon_notif(struct iwl_mvm *mvm,
1628 			     struct iwl_rx_cmd_buffer *rxb);
1629 void iwl_mvm_rx_missed_beacons_notif(struct iwl_mvm *mvm,
1630 				     struct iwl_rx_cmd_buffer *rxb);
1631 void iwl_mvm_rx_stored_beacon_notif(struct iwl_mvm *mvm,
1632 				    struct iwl_rx_cmd_buffer *rxb);
1633 void iwl_mvm_mu_mimo_grp_notif(struct iwl_mvm *mvm,
1634 			       struct iwl_rx_cmd_buffer *rxb);
1635 void iwl_mvm_sta_pm_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb);
1636 void iwl_mvm_window_status_notif(struct iwl_mvm *mvm,
1637 				 struct iwl_rx_cmd_buffer *rxb);
1638 void iwl_mvm_mac_ctxt_recalc_tsf_id(struct iwl_mvm *mvm,
1639 				    struct ieee80211_vif *vif);
1640 void iwl_mvm_probe_resp_data_notif(struct iwl_mvm *mvm,
1641 				   struct iwl_rx_cmd_buffer *rxb);
1642 void iwl_mvm_rx_missed_vap_notif(struct iwl_mvm *mvm,
1643 				 struct iwl_rx_cmd_buffer *rxb);
1644 void iwl_mvm_channel_switch_noa_notif(struct iwl_mvm *mvm,
1645 				      struct iwl_rx_cmd_buffer *rxb);
1646 /* Bindings */
1647 int iwl_mvm_binding_add_vif(struct iwl_mvm *mvm, struct ieee80211_vif *vif);
1648 int iwl_mvm_binding_remove_vif(struct iwl_mvm *mvm, struct ieee80211_vif *vif);
1649 
1650 /* Quota management */
1651 static inline size_t iwl_mvm_quota_cmd_size(struct iwl_mvm *mvm)
1652 {
1653 	return iwl_mvm_has_quota_low_latency(mvm) ?
1654 		sizeof(struct iwl_time_quota_cmd) :
1655 		sizeof(struct iwl_time_quota_cmd_v1);
1656 }
1657 
1658 static inline struct iwl_time_quota_data
1659 *iwl_mvm_quota_cmd_get_quota(struct iwl_mvm *mvm,
1660 			     struct iwl_time_quota_cmd *cmd,
1661 			     int i)
1662 {
1663 	struct iwl_time_quota_data_v1 *quotas;
1664 
1665 	if (iwl_mvm_has_quota_low_latency(mvm))
1666 		return &cmd->quotas[i];
1667 
1668 	quotas = (struct iwl_time_quota_data_v1 *)cmd->quotas;
1669 	return (struct iwl_time_quota_data *)&quotas[i];
1670 }
1671 
1672 int iwl_mvm_update_quotas(struct iwl_mvm *mvm, bool force_upload,
1673 			  struct ieee80211_vif *disabled_vif);
1674 
1675 /* Scanning */
1676 int iwl_mvm_reg_scan_start(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1677 			   struct cfg80211_scan_request *req,
1678 			   struct ieee80211_scan_ies *ies);
1679 int iwl_mvm_scan_size(struct iwl_mvm *mvm);
1680 int iwl_mvm_scan_stop(struct iwl_mvm *mvm, int type, bool notify);
1681 int iwl_mvm_max_scan_ie_len(struct iwl_mvm *mvm);
1682 void iwl_mvm_report_scan_aborted(struct iwl_mvm *mvm);
1683 void iwl_mvm_scan_timeout_wk(struct work_struct *work);
1684 
1685 /* Scheduled scan */
1686 void iwl_mvm_rx_lmac_scan_complete_notif(struct iwl_mvm *mvm,
1687 					 struct iwl_rx_cmd_buffer *rxb);
1688 void iwl_mvm_rx_lmac_scan_iter_complete_notif(struct iwl_mvm *mvm,
1689 					      struct iwl_rx_cmd_buffer *rxb);
1690 int iwl_mvm_sched_scan_start(struct iwl_mvm *mvm,
1691 			     struct ieee80211_vif *vif,
1692 			     struct cfg80211_sched_scan_request *req,
1693 			     struct ieee80211_scan_ies *ies,
1694 			     int type);
1695 void iwl_mvm_rx_scan_match_found(struct iwl_mvm *mvm,
1696 				 struct iwl_rx_cmd_buffer *rxb);
1697 
1698 /* UMAC scan */
1699 int iwl_mvm_config_scan(struct iwl_mvm *mvm);
1700 void iwl_mvm_rx_umac_scan_complete_notif(struct iwl_mvm *mvm,
1701 					 struct iwl_rx_cmd_buffer *rxb);
1702 void iwl_mvm_rx_umac_scan_iter_complete_notif(struct iwl_mvm *mvm,
1703 					      struct iwl_rx_cmd_buffer *rxb);
1704 
1705 /* MVM debugfs */
1706 #ifdef CONFIG_IWLWIFI_DEBUGFS
1707 void iwl_mvm_dbgfs_register(struct iwl_mvm *mvm);
1708 void iwl_mvm_vif_dbgfs_register(struct iwl_mvm *mvm, struct ieee80211_vif *vif);
1709 void iwl_mvm_vif_dbgfs_clean(struct iwl_mvm *mvm, struct ieee80211_vif *vif);
1710 #else
1711 static inline void iwl_mvm_dbgfs_register(struct iwl_mvm *mvm)
1712 {
1713 }
1714 static inline void
1715 iwl_mvm_vif_dbgfs_register(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1716 {
1717 }
1718 static inline void
1719 iwl_mvm_vif_dbgfs_clean(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1720 {
1721 }
1722 #endif /* CONFIG_IWLWIFI_DEBUGFS */
1723 
1724 /* rate scaling */
1725 int iwl_mvm_send_lq_cmd(struct iwl_mvm *mvm, struct iwl_lq_cmd *lq);
1726 void iwl_mvm_update_frame_stats(struct iwl_mvm *mvm, u32 rate, bool agg);
1727 int rs_pretty_print_rate(char *buf, int bufsz, const u32 rate);
1728 void rs_update_last_rssi(struct iwl_mvm *mvm,
1729 			 struct iwl_mvm_sta *mvmsta,
1730 			 struct ieee80211_rx_status *rx_status);
1731 
1732 /* power management */
1733 int iwl_mvm_power_update_device(struct iwl_mvm *mvm);
1734 int iwl_mvm_power_update_mac(struct iwl_mvm *mvm);
1735 int iwl_mvm_power_update_ps(struct iwl_mvm *mvm);
1736 int iwl_mvm_power_mac_dbgfs_read(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1737 				 char *buf, int bufsz);
1738 
1739 void iwl_mvm_power_vif_assoc(struct iwl_mvm *mvm, struct ieee80211_vif *vif);
1740 void iwl_mvm_power_uapsd_misbehaving_ap_notif(struct iwl_mvm *mvm,
1741 					      struct iwl_rx_cmd_buffer *rxb);
1742 
1743 #ifdef CONFIG_IWLWIFI_LEDS
1744 int iwl_mvm_leds_init(struct iwl_mvm *mvm);
1745 void iwl_mvm_leds_exit(struct iwl_mvm *mvm);
1746 void iwl_mvm_leds_sync(struct iwl_mvm *mvm);
1747 #else
1748 static inline int iwl_mvm_leds_init(struct iwl_mvm *mvm)
1749 {
1750 	return 0;
1751 }
1752 static inline void iwl_mvm_leds_exit(struct iwl_mvm *mvm)
1753 {
1754 }
1755 static inline void iwl_mvm_leds_sync(struct iwl_mvm *mvm)
1756 {
1757 }
1758 #endif
1759 
1760 /* D3 (WoWLAN, NetDetect) */
1761 int iwl_mvm_suspend(struct ieee80211_hw *hw, struct cfg80211_wowlan *wowlan);
1762 int iwl_mvm_resume(struct ieee80211_hw *hw);
1763 void iwl_mvm_set_wakeup(struct ieee80211_hw *hw, bool enabled);
1764 void iwl_mvm_set_rekey_data(struct ieee80211_hw *hw,
1765 			    struct ieee80211_vif *vif,
1766 			    struct cfg80211_gtk_rekey_data *data);
1767 void iwl_mvm_ipv6_addr_change(struct ieee80211_hw *hw,
1768 			      struct ieee80211_vif *vif,
1769 			      struct inet6_dev *idev);
1770 void iwl_mvm_set_default_unicast_key(struct ieee80211_hw *hw,
1771 				     struct ieee80211_vif *vif, int idx);
1772 extern const struct file_operations iwl_dbgfs_d3_test_ops;
1773 struct iwl_wowlan_status *iwl_mvm_send_wowlan_get_status(struct iwl_mvm *mvm);
1774 #ifdef CONFIG_PM
1775 void iwl_mvm_set_last_nonqos_seq(struct iwl_mvm *mvm,
1776 				 struct ieee80211_vif *vif);
1777 #else
1778 static inline void
1779 iwl_mvm_set_last_nonqos_seq(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1780 {
1781 }
1782 #endif
1783 void iwl_mvm_set_wowlan_qos_seq(struct iwl_mvm_sta *mvm_ap_sta,
1784 				struct iwl_wowlan_config_cmd *cmd);
1785 int iwl_mvm_send_proto_offload(struct iwl_mvm *mvm,
1786 			       struct ieee80211_vif *vif,
1787 			       bool disable_offloading,
1788 			       bool offload_ns,
1789 			       u32 cmd_flags);
1790 
1791 /* BT Coex */
1792 int iwl_mvm_send_bt_init_conf(struct iwl_mvm *mvm);
1793 void iwl_mvm_rx_bt_coex_notif(struct iwl_mvm *mvm,
1794 			      struct iwl_rx_cmd_buffer *rxb);
1795 void iwl_mvm_bt_rssi_event(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1796 			   enum ieee80211_rssi_event_data);
1797 void iwl_mvm_bt_coex_vif_change(struct iwl_mvm *mvm);
1798 u16 iwl_mvm_coex_agg_time_limit(struct iwl_mvm *mvm,
1799 				struct ieee80211_sta *sta);
1800 bool iwl_mvm_bt_coex_is_mimo_allowed(struct iwl_mvm *mvm,
1801 				     struct ieee80211_sta *sta);
1802 bool iwl_mvm_bt_coex_is_ant_avail(struct iwl_mvm *mvm, u8 ant);
1803 bool iwl_mvm_bt_coex_is_shared_ant_avail(struct iwl_mvm *mvm);
1804 bool iwl_mvm_bt_coex_is_tpc_allowed(struct iwl_mvm *mvm,
1805 				    enum nl80211_band band);
1806 u8 iwl_mvm_bt_coex_get_single_ant_msk(struct iwl_mvm *mvm, u8 enabled_ants);
1807 u8 iwl_mvm_bt_coex_tx_prio(struct iwl_mvm *mvm, struct ieee80211_hdr *hdr,
1808 			   struct ieee80211_tx_info *info, u8 ac);
1809 
1810 /* beacon filtering */
1811 #ifdef CONFIG_IWLWIFI_DEBUGFS
1812 void
1813 iwl_mvm_beacon_filter_debugfs_parameters(struct ieee80211_vif *vif,
1814 					 struct iwl_beacon_filter_cmd *cmd);
1815 #else
1816 static inline void
1817 iwl_mvm_beacon_filter_debugfs_parameters(struct ieee80211_vif *vif,
1818 					 struct iwl_beacon_filter_cmd *cmd)
1819 {}
1820 #endif
1821 int iwl_mvm_enable_beacon_filter(struct iwl_mvm *mvm,
1822 				 struct ieee80211_vif *vif,
1823 				 u32 flags);
1824 int iwl_mvm_disable_beacon_filter(struct iwl_mvm *mvm,
1825 				  struct ieee80211_vif *vif,
1826 				  u32 flags);
1827 /* SMPS */
1828 void iwl_mvm_update_smps(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1829 				enum iwl_mvm_smps_type_request req_type,
1830 				enum ieee80211_smps_mode smps_request);
1831 bool iwl_mvm_rx_diversity_allowed(struct iwl_mvm *mvm);
1832 
1833 /* Low latency */
1834 int iwl_mvm_update_low_latency(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1835 			      bool low_latency,
1836 			      enum iwl_mvm_low_latency_cause cause);
1837 /* get SystemLowLatencyMode - only needed for beacon threshold? */
1838 bool iwl_mvm_low_latency(struct iwl_mvm *mvm);
1839 bool iwl_mvm_low_latency_band(struct iwl_mvm *mvm, enum nl80211_band band);
1840 void iwl_mvm_send_low_latency_cmd(struct iwl_mvm *mvm, bool low_latency,
1841 				  u16 mac_id);
1842 
1843 /* get VMACLowLatencyMode */
1844 static inline bool iwl_mvm_vif_low_latency(struct iwl_mvm_vif *mvmvif)
1845 {
1846 	/*
1847 	 * should this consider associated/active/... state?
1848 	 *
1849 	 * Normally low-latency should only be active on interfaces
1850 	 * that are active, but at least with debugfs it can also be
1851 	 * enabled on interfaces that aren't active. However, when
1852 	 * interface aren't active then they aren't added into the
1853 	 * binding, so this has no real impact. For now, just return
1854 	 * the current desired low-latency state.
1855 	 */
1856 	return mvmvif->low_latency_actual;
1857 }
1858 
1859 static inline
1860 void iwl_mvm_vif_set_low_latency(struct iwl_mvm_vif *mvmvif, bool set,
1861 				 enum iwl_mvm_low_latency_cause cause)
1862 {
1863 	u8 new_state;
1864 
1865 	if (set)
1866 		mvmvif->low_latency |= cause;
1867 	else
1868 		mvmvif->low_latency &= ~cause;
1869 
1870 	/*
1871 	 * if LOW_LATENCY_DEBUGFS_FORCE_ENABLE is enabled no changes are
1872 	 * allowed to actual mode.
1873 	 */
1874 	if (mvmvif->low_latency & LOW_LATENCY_DEBUGFS_FORCE_ENABLE &&
1875 	    cause != LOW_LATENCY_DEBUGFS_FORCE_ENABLE)
1876 		return;
1877 
1878 	if (cause == LOW_LATENCY_DEBUGFS_FORCE_ENABLE && set)
1879 		/*
1880 		 * We enter force state
1881 		 */
1882 		new_state = !!(mvmvif->low_latency &
1883 			       LOW_LATENCY_DEBUGFS_FORCE);
1884 	else
1885 		/*
1886 		 * Check if any other one set low latency
1887 		 */
1888 		new_state = !!(mvmvif->low_latency &
1889 				  ~(LOW_LATENCY_DEBUGFS_FORCE_ENABLE |
1890 				    LOW_LATENCY_DEBUGFS_FORCE));
1891 
1892 	mvmvif->low_latency_actual = new_state;
1893 }
1894 
1895 /* Return a bitmask with all the hw supported queues, except for the
1896  * command queue, which can't be flushed.
1897  */
1898 static inline u32 iwl_mvm_flushable_queues(struct iwl_mvm *mvm)
1899 {
1900 	return ((BIT(mvm->trans->trans_cfg->base_params->num_of_queues) - 1) &
1901 		~BIT(IWL_MVM_DQA_CMD_QUEUE));
1902 }
1903 
1904 void iwl_mvm_stop_device(struct iwl_mvm *mvm);
1905 
1906 /* Re-configure the SCD for a queue that has already been configured */
1907 int iwl_mvm_reconfig_scd(struct iwl_mvm *mvm, int queue, int fifo, int sta_id,
1908 			 int tid, int frame_limit, u16 ssn);
1909 
1910 /* Thermal management and CT-kill */
1911 void iwl_mvm_tt_tx_backoff(struct iwl_mvm *mvm, u32 backoff);
1912 void iwl_mvm_temp_notif(struct iwl_mvm *mvm,
1913 			struct iwl_rx_cmd_buffer *rxb);
1914 void iwl_mvm_tt_handler(struct iwl_mvm *mvm);
1915 void iwl_mvm_thermal_initialize(struct iwl_mvm *mvm, u32 min_backoff);
1916 void iwl_mvm_thermal_exit(struct iwl_mvm *mvm);
1917 void iwl_mvm_set_hw_ctkill_state(struct iwl_mvm *mvm, bool state);
1918 int iwl_mvm_get_temp(struct iwl_mvm *mvm, s32 *temp);
1919 void iwl_mvm_ct_kill_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb);
1920 void iwl_mvm_enter_ctkill(struct iwl_mvm *mvm);
1921 int iwl_mvm_send_temp_report_ths_cmd(struct iwl_mvm *mvm);
1922 int iwl_mvm_ctdp_command(struct iwl_mvm *mvm, u32 op, u32 budget);
1923 
1924 /* Location Aware Regulatory */
1925 struct iwl_mcc_update_resp *
1926 iwl_mvm_update_mcc(struct iwl_mvm *mvm, const char *alpha2,
1927 		   enum iwl_mcc_source src_id);
1928 int iwl_mvm_init_mcc(struct iwl_mvm *mvm);
1929 void iwl_mvm_rx_chub_update_mcc(struct iwl_mvm *mvm,
1930 				struct iwl_rx_cmd_buffer *rxb);
1931 struct ieee80211_regdomain *iwl_mvm_get_regdomain(struct wiphy *wiphy,
1932 						  const char *alpha2,
1933 						  enum iwl_mcc_source src_id,
1934 						  bool *changed);
1935 struct ieee80211_regdomain *iwl_mvm_get_current_regdomain(struct iwl_mvm *mvm,
1936 							  bool *changed);
1937 int iwl_mvm_init_fw_regd(struct iwl_mvm *mvm);
1938 void iwl_mvm_update_changed_regdom(struct iwl_mvm *mvm);
1939 
1940 /* smart fifo */
1941 int iwl_mvm_sf_update(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1942 		      bool added_vif);
1943 
1944 /* FTM responder */
1945 int iwl_mvm_ftm_start_responder(struct iwl_mvm *mvm, struct ieee80211_vif *vif);
1946 void iwl_mvm_ftm_restart_responder(struct iwl_mvm *mvm,
1947 				   struct ieee80211_vif *vif);
1948 void iwl_mvm_ftm_responder_stats(struct iwl_mvm *mvm,
1949 				 struct iwl_rx_cmd_buffer *rxb);
1950 int iwl_mvm_ftm_resp_remove_pasn_sta(struct iwl_mvm *mvm,
1951 				     struct ieee80211_vif *vif, u8 *addr);
1952 int iwl_mvm_ftm_respoder_add_pasn_sta(struct iwl_mvm *mvm,
1953 				      struct ieee80211_vif *vif,
1954 				      u8 *addr, u32 cipher, u8 *tk, u32 tk_len,
1955 				      u8 *hltk, u32 hltk_len);
1956 void iwl_mvm_ftm_responder_clear(struct iwl_mvm *mvm,
1957 				 struct ieee80211_vif *vif);
1958 
1959 /* FTM initiator */
1960 void iwl_mvm_ftm_restart(struct iwl_mvm *mvm);
1961 void iwl_mvm_ftm_range_resp(struct iwl_mvm *mvm,
1962 			    struct iwl_rx_cmd_buffer *rxb);
1963 void iwl_mvm_ftm_lc_notif(struct iwl_mvm *mvm,
1964 			  struct iwl_rx_cmd_buffer *rxb);
1965 int iwl_mvm_ftm_start(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1966 		      struct cfg80211_pmsr_request *request);
1967 void iwl_mvm_ftm_abort(struct iwl_mvm *mvm, struct cfg80211_pmsr_request *req);
1968 void iwl_mvm_ftm_initiator_smooth_config(struct iwl_mvm *mvm);
1969 void iwl_mvm_ftm_initiator_smooth_stop(struct iwl_mvm *mvm);
1970 int iwl_mvm_ftm_add_pasn_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1971 			     u8 *addr, u32 cipher, u8 *tk, u32 tk_len,
1972 			     u8 *hltk, u32 hltk_len);
1973 void iwl_mvm_ftm_remove_pasn_sta(struct iwl_mvm *mvm, u8 *addr);
1974 
1975 /* TDLS */
1976 
1977 /*
1978  * We use TID 4 (VI) as a FW-used-only TID when TDLS connections are present.
1979  * This TID is marked as used vs the AP and all connected TDLS peers.
1980  */
1981 #define IWL_MVM_TDLS_FW_TID 4
1982 
1983 int iwl_mvm_tdls_sta_count(struct iwl_mvm *mvm, struct ieee80211_vif *vif);
1984 void iwl_mvm_teardown_tdls_peers(struct iwl_mvm *mvm);
1985 void iwl_mvm_recalc_tdls_state(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1986 			       bool sta_added);
1987 void iwl_mvm_mac_mgd_protect_tdls_discover(struct ieee80211_hw *hw,
1988 					   struct ieee80211_vif *vif);
1989 int iwl_mvm_tdls_channel_switch(struct ieee80211_hw *hw,
1990 				struct ieee80211_vif *vif,
1991 				struct ieee80211_sta *sta, u8 oper_class,
1992 				struct cfg80211_chan_def *chandef,
1993 				struct sk_buff *tmpl_skb, u32 ch_sw_tm_ie);
1994 void iwl_mvm_tdls_recv_channel_switch(struct ieee80211_hw *hw,
1995 				      struct ieee80211_vif *vif,
1996 				      struct ieee80211_tdls_ch_sw_params *params);
1997 void iwl_mvm_tdls_cancel_channel_switch(struct ieee80211_hw *hw,
1998 					struct ieee80211_vif *vif,
1999 					struct ieee80211_sta *sta);
2000 void iwl_mvm_rx_tdls_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb);
2001 void iwl_mvm_tdls_ch_switch_work(struct work_struct *work);
2002 
2003 void iwl_mvm_sync_rx_queues_internal(struct iwl_mvm *mvm,
2004 				     struct iwl_mvm_internal_rxq_notif *notif,
2005 				     u32 size);
2006 void iwl_mvm_reorder_timer_expired(struct timer_list *t);
2007 struct ieee80211_vif *iwl_mvm_get_bss_vif(struct iwl_mvm *mvm);
2008 struct ieee80211_vif *iwl_mvm_get_vif_by_macid(struct iwl_mvm *mvm, u32 macid);
2009 bool iwl_mvm_is_vif_assoc(struct iwl_mvm *mvm);
2010 
2011 #define MVM_TCM_PERIOD_MSEC 500
2012 #define MVM_TCM_PERIOD (HZ * MVM_TCM_PERIOD_MSEC / 1000)
2013 #define MVM_LL_PERIOD (10 * HZ)
2014 void iwl_mvm_tcm_work(struct work_struct *work);
2015 void iwl_mvm_recalc_tcm(struct iwl_mvm *mvm);
2016 void iwl_mvm_pause_tcm(struct iwl_mvm *mvm, bool with_cancel);
2017 void iwl_mvm_resume_tcm(struct iwl_mvm *mvm);
2018 void iwl_mvm_tcm_add_vif(struct iwl_mvm *mvm, struct ieee80211_vif *vif);
2019 void iwl_mvm_tcm_rm_vif(struct iwl_mvm *mvm, struct ieee80211_vif *vif);
2020 u8 iwl_mvm_tcm_load_percentage(u32 airtime, u32 elapsed);
2021 
2022 void iwl_mvm_nic_restart(struct iwl_mvm *mvm, bool fw_error);
2023 unsigned int iwl_mvm_get_wd_timeout(struct iwl_mvm *mvm,
2024 				    struct ieee80211_vif *vif,
2025 				    bool tdls, bool cmd_q);
2026 void iwl_mvm_connection_loss(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
2027 			     const char *errmsg);
2028 void iwl_mvm_event_frame_timeout_callback(struct iwl_mvm *mvm,
2029 					  struct ieee80211_vif *vif,
2030 					  const struct ieee80211_sta *sta,
2031 					  u16 tid);
2032 
2033 int iwl_mvm_sar_select_profile(struct iwl_mvm *mvm, int prof_a, int prof_b);
2034 int iwl_mvm_get_sar_geo_profile(struct iwl_mvm *mvm);
2035 int iwl_mvm_ppag_send_cmd(struct iwl_mvm *mvm);
2036 #ifdef CONFIG_IWLWIFI_DEBUGFS
2037 void iwl_mvm_sta_add_debugfs(struct ieee80211_hw *hw,
2038 			     struct ieee80211_vif *vif,
2039 			     struct ieee80211_sta *sta,
2040 			     struct dentry *dir);
2041 #endif
2042 
2043 int iwl_rfi_send_config_cmd(struct iwl_mvm *mvm,
2044 			    struct iwl_rfi_lut_entry *rfi_table);
2045 struct iwl_rfi_freq_table_resp_cmd *iwl_rfi_get_freq_table(struct iwl_mvm *mvm);
2046 
2047 static inline u8 iwl_mvm_phy_band_from_nl80211(enum nl80211_band band)
2048 {
2049 	switch (band) {
2050 	case NL80211_BAND_2GHZ:
2051 		return PHY_BAND_24;
2052 	case NL80211_BAND_5GHZ:
2053 		return PHY_BAND_5;
2054 	case NL80211_BAND_6GHZ:
2055 		return PHY_BAND_6;
2056 	default:
2057 		WARN_ONCE(1, "Unsupported band (%u)\n", band);
2058 		return PHY_BAND_5;
2059 	}
2060 }
2061 
2062 /* Channel info utils */
2063 static inline bool iwl_mvm_has_ultra_hb_channel(struct iwl_mvm *mvm)
2064 {
2065 	return fw_has_capa(&mvm->fw->ucode_capa,
2066 			   IWL_UCODE_TLV_CAPA_ULTRA_HB_CHANNELS);
2067 }
2068 
2069 static inline void *iwl_mvm_chan_info_cmd_tail(struct iwl_mvm *mvm,
2070 					       struct iwl_fw_channel_info *ci)
2071 {
2072 	return (u8 *)ci + (iwl_mvm_has_ultra_hb_channel(mvm) ?
2073 			   sizeof(struct iwl_fw_channel_info) :
2074 			   sizeof(struct iwl_fw_channel_info_v1));
2075 }
2076 
2077 static inline size_t iwl_mvm_chan_info_padding(struct iwl_mvm *mvm)
2078 {
2079 	return iwl_mvm_has_ultra_hb_channel(mvm) ? 0 :
2080 		sizeof(struct iwl_fw_channel_info) -
2081 		sizeof(struct iwl_fw_channel_info_v1);
2082 }
2083 
2084 static inline void iwl_mvm_set_chan_info(struct iwl_mvm *mvm,
2085 					 struct iwl_fw_channel_info *ci,
2086 					 u32 chan, u8 band, u8 width,
2087 					 u8 ctrl_pos)
2088 {
2089 	if (iwl_mvm_has_ultra_hb_channel(mvm)) {
2090 		ci->channel = cpu_to_le32(chan);
2091 		ci->band = band;
2092 		ci->width = width;
2093 		ci->ctrl_pos = ctrl_pos;
2094 	} else {
2095 		struct iwl_fw_channel_info_v1 *ci_v1 =
2096 					(struct iwl_fw_channel_info_v1 *)ci;
2097 
2098 		ci_v1->channel = chan;
2099 		ci_v1->band = band;
2100 		ci_v1->width = width;
2101 		ci_v1->ctrl_pos = ctrl_pos;
2102 	}
2103 }
2104 
2105 static inline void
2106 iwl_mvm_set_chan_info_chandef(struct iwl_mvm *mvm,
2107 			      struct iwl_fw_channel_info *ci,
2108 			      struct cfg80211_chan_def *chandef)
2109 {
2110 	enum nl80211_band band = chandef->chan->band;
2111 
2112 	iwl_mvm_set_chan_info(mvm, ci, chandef->chan->hw_value,
2113 			      iwl_mvm_phy_band_from_nl80211(band),
2114 			      iwl_mvm_get_channel_width(chandef),
2115 			      iwl_mvm_get_ctrl_pos(chandef));
2116 }
2117 
2118 static inline int iwl_umac_scan_get_max_profiles(const struct iwl_fw *fw)
2119 {
2120 	u8 ver = iwl_fw_lookup_cmd_ver(fw, IWL_ALWAYS_LONG_GROUP,
2121 				       SCAN_OFFLOAD_UPDATE_PROFILES_CMD,
2122 				       IWL_FW_CMD_VER_UNKNOWN);
2123 	return (ver == IWL_FW_CMD_VER_UNKNOWN || ver < 3) ?
2124 		IWL_SCAN_MAX_PROFILES : IWL_SCAN_MAX_PROFILES_V2;
2125 }
2126 
2127 static inline
2128 enum iwl_location_cipher iwl_mvm_cipher_to_location_cipher(u32 cipher)
2129 {
2130 	switch (cipher) {
2131 	case WLAN_CIPHER_SUITE_CCMP:
2132 		return IWL_LOCATION_CIPHER_CCMP_128;
2133 	case WLAN_CIPHER_SUITE_GCMP:
2134 		return IWL_LOCATION_CIPHER_GCMP_128;
2135 	case WLAN_CIPHER_SUITE_GCMP_256:
2136 		return IWL_LOCATION_CIPHER_GCMP_256;
2137 	default:
2138 		return IWL_LOCATION_CIPHER_INVALID;
2139 	}
2140 }
2141 #endif /* __IWL_MVM_H__ */
2142