debugfs-vif.c

  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#include "mvm.h"
  8#include "debugfs.h"
  9
 10static void iwl_dbgfs_update_pm(struct iwl_mvm *mvm,
 11				 struct ieee80211_vif *vif,
 12				 enum iwl_dbgfs_pm_mask param, int val)
 13{
 14	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 15	struct iwl_dbgfs_pm *dbgfs_pm = &mvmvif->dbgfs_pm;
 16
 17	dbgfs_pm->mask |= param;
 18
 19	switch (param) {
 20	case MVM_DEBUGFS_PM_KEEP_ALIVE: {
 21		int dtimper = vif->bss_conf.dtim_period ?: 1;
 22		int dtimper_msec = dtimper * vif->bss_conf.beacon_int;
 23
 24		IWL_DEBUG_POWER(mvm, "debugfs: set keep_alive= %d sec\n", val);
 25		if (val * MSEC_PER_SEC < 3 * dtimper_msec)
 26			IWL_WARN(mvm,
 27				 "debugfs: keep alive period (%ld msec) is less than minimum required (%d msec)\n",
 28				 val * MSEC_PER_SEC, 3 * dtimper_msec);
 29		dbgfs_pm->keep_alive_seconds = val;
 30		break;
 31	}
 32	case MVM_DEBUGFS_PM_SKIP_OVER_DTIM:
 33		IWL_DEBUG_POWER(mvm, "skip_over_dtim %s\n",
 34				val ? "enabled" : "disabled");
 35		dbgfs_pm->skip_over_dtim = val;
 36		break;
 37	case MVM_DEBUGFS_PM_SKIP_DTIM_PERIODS:
 38		IWL_DEBUG_POWER(mvm, "skip_dtim_periods=%d\n", val);
 39		dbgfs_pm->skip_dtim_periods = val;
 40		break;
 41	case MVM_DEBUGFS_PM_RX_DATA_TIMEOUT:
 42		IWL_DEBUG_POWER(mvm, "rx_data_timeout=%d\n", val);
 43		dbgfs_pm->rx_data_timeout = val;
 44		break;
 45	case MVM_DEBUGFS_PM_TX_DATA_TIMEOUT:
 46		IWL_DEBUG_POWER(mvm, "tx_data_timeout=%d\n", val);
 47		dbgfs_pm->tx_data_timeout = val;
 48		break;
 49	case MVM_DEBUGFS_PM_LPRX_ENA:
 50		IWL_DEBUG_POWER(mvm, "lprx %s\n", val ? "enabled" : "disabled");
 51		dbgfs_pm->lprx_ena = val;
 52		break;
 53	case MVM_DEBUGFS_PM_LPRX_RSSI_THRESHOLD:
 54		IWL_DEBUG_POWER(mvm, "lprx_rssi_threshold=%d\n", val);
 55		dbgfs_pm->lprx_rssi_threshold = val;
 56		break;
 57	case MVM_DEBUGFS_PM_SNOOZE_ENABLE:
 58		IWL_DEBUG_POWER(mvm, "snooze_enable=%d\n", val);
 59		dbgfs_pm->snooze_ena = val;
 60		break;
 61	case MVM_DEBUGFS_PM_UAPSD_MISBEHAVING:
 62		IWL_DEBUG_POWER(mvm, "uapsd_misbehaving_enable=%d\n", val);
 63		dbgfs_pm->uapsd_misbehaving = val;
 64		break;
 65	case MVM_DEBUGFS_PM_USE_PS_POLL:
 66		IWL_DEBUG_POWER(mvm, "use_ps_poll=%d\n", val);
 67		dbgfs_pm->use_ps_poll = val;
 68		break;
 69	}
 70}
 71
 72static ssize_t iwl_dbgfs_pm_params_write(struct ieee80211_vif *vif, char *buf,
 73					 size_t count, loff_t *ppos)
 74{
 75	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 76	struct iwl_mvm *mvm = mvmvif->mvm;
 77	enum iwl_dbgfs_pm_mask param;
 78	int val, ret;
 79
 80	if (!strncmp("keep_alive=", buf, 11)) {
 81		if (sscanf(buf + 11, "%d", &val) != 1)
 82			return -EINVAL;
 83		param = MVM_DEBUGFS_PM_KEEP_ALIVE;
 84	} else if (!strncmp("skip_over_dtim=", buf, 15)) {
 85		if (sscanf(buf + 15, "%d", &val) != 1)
 86			return -EINVAL;
 87		param = MVM_DEBUGFS_PM_SKIP_OVER_DTIM;
 88	} else if (!strncmp("skip_dtim_periods=", buf, 18)) {
 89		if (sscanf(buf + 18, "%d", &val) != 1)
 90			return -EINVAL;
 91		param = MVM_DEBUGFS_PM_SKIP_DTIM_PERIODS;
 92	} else if (!strncmp("rx_data_timeout=", buf, 16)) {
 93		if (sscanf(buf + 16, "%d", &val) != 1)
 94			return -EINVAL;
 95		param = MVM_DEBUGFS_PM_RX_DATA_TIMEOUT;
 96	} else if (!strncmp("tx_data_timeout=", buf, 16)) {
 97		if (sscanf(buf + 16, "%d", &val) != 1)
 98			return -EINVAL;
 99		param = MVM_DEBUGFS_PM_TX_DATA_TIMEOUT;
100	} else if (!strncmp("lprx=", buf, 5)) {
101		if (sscanf(buf + 5, "%d", &val) != 1)
102			return -EINVAL;
103		param = MVM_DEBUGFS_PM_LPRX_ENA;
104	} else if (!strncmp("lprx_rssi_threshold=", buf, 20)) {
105		if (sscanf(buf + 20, "%d", &val) != 1)
106			return -EINVAL;
107		if (val > POWER_LPRX_RSSI_THRESHOLD_MAX || val <
108		    POWER_LPRX_RSSI_THRESHOLD_MIN)
109			return -EINVAL;
110		param = MVM_DEBUGFS_PM_LPRX_RSSI_THRESHOLD;
111	} else if (!strncmp("snooze_enable=", buf, 14)) {
112		if (sscanf(buf + 14, "%d", &val) != 1)
113			return -EINVAL;
114		param = MVM_DEBUGFS_PM_SNOOZE_ENABLE;
115	} else if (!strncmp("uapsd_misbehaving=", buf, 18)) {
116		if (sscanf(buf + 18, "%d", &val) != 1)
117			return -EINVAL;
118		param = MVM_DEBUGFS_PM_UAPSD_MISBEHAVING;
119	} else if (!strncmp("use_ps_poll=", buf, 12)) {
120		if (sscanf(buf + 12, "%d", &val) != 1)
121			return -EINVAL;
122		param = MVM_DEBUGFS_PM_USE_PS_POLL;
123	} else {
124		return -EINVAL;
125	}
126
127	mutex_lock(&mvm->mutex);
128	iwl_dbgfs_update_pm(mvm, vif, param, val);
129	ret = iwl_mvm_power_update_mac(mvm);
130	mutex_unlock(&mvm->mutex);
131
132	return ret ?: count;
133}
134
135static ssize_t iwl_dbgfs_tx_pwr_lmt_read(struct file *file,
136					 char __user *user_buf,
137					 size_t count, loff_t *ppos)
138{
139	struct ieee80211_vif *vif = file->private_data;
140	char buf[64];
141	int bufsz = sizeof(buf);
142	int pos;
143
144	pos = scnprintf(buf, bufsz, "bss limit = %d\n",
145			vif->bss_conf.txpower);
146
147	return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
148}
149
150static ssize_t iwl_dbgfs_pm_params_read(struct file *file,
151					char __user *user_buf,
152					size_t count, loff_t *ppos)
153{
154	struct ieee80211_vif *vif = file->private_data;
155	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
156	struct iwl_mvm *mvm = mvmvif->mvm;
157	char buf[512];
158	int bufsz = sizeof(buf);
159	int pos;
160
161	pos = iwl_mvm_power_mac_dbgfs_read(mvm, vif, buf, bufsz);
162
163	return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
164}
165
166static ssize_t iwl_dbgfs_mac_params_read(struct file *file,
167					 char __user *user_buf,
168					 size_t count, loff_t *ppos)
169{
170	struct ieee80211_vif *vif = file->private_data;
171	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
172	struct iwl_mvm *mvm = mvmvif->mvm;
173	u8 ap_sta_id;
174	struct ieee80211_chanctx_conf *chanctx_conf;
175	char buf[512];
176	int bufsz = sizeof(buf);
177	int pos = 0;
178	int i;
179
180	mutex_lock(&mvm->mutex);
181
182	ap_sta_id = mvmvif->deflink.ap_sta_id;
183
184	switch (ieee80211_vif_type_p2p(vif)) {
185	case NL80211_IFTYPE_ADHOC:
186		pos += scnprintf(buf+pos, bufsz-pos, "type: ibss\n");
187		break;
188	case NL80211_IFTYPE_STATION:
189		pos += scnprintf(buf+pos, bufsz-pos, "type: bss\n");
190		break;
191	case NL80211_IFTYPE_AP:
192		pos += scnprintf(buf+pos, bufsz-pos, "type: ap\n");
193		break;
194	case NL80211_IFTYPE_P2P_CLIENT:
195		pos += scnprintf(buf+pos, bufsz-pos, "type: p2p client\n");
196		break;
197	case NL80211_IFTYPE_P2P_GO:
198		pos += scnprintf(buf+pos, bufsz-pos, "type: p2p go\n");
199		break;
200	case NL80211_IFTYPE_P2P_DEVICE:
201		pos += scnprintf(buf+pos, bufsz-pos, "type: p2p dev\n");
202		break;
203	default:
204		break;
205	}
206
207	pos += scnprintf(buf+pos, bufsz-pos, "mac id/color: %d / %d\n",
208			 mvmvif->id, mvmvif->color);
209	pos += scnprintf(buf+pos, bufsz-pos, "bssid: %pM\n",
210			 vif->bss_conf.bssid);
211	pos += scnprintf(buf+pos, bufsz-pos, "Load: %d\n",
212			 mvm->tcm.result.load[mvmvif->id]);
213	pos += scnprintf(buf+pos, bufsz-pos, "QoS:\n");
214	for (i = 0; i < ARRAY_SIZE(mvmvif->deflink.queue_params); i++)
215		pos += scnprintf(buf+pos, bufsz-pos,
216				 "\t%d: txop:%d - cw_min:%d - cw_max = %d - aifs = %d upasd = %d\n",
217				 i, mvmvif->deflink.queue_params[i].txop,
218				 mvmvif->deflink.queue_params[i].cw_min,
219				 mvmvif->deflink.queue_params[i].cw_max,
220				 mvmvif->deflink.queue_params[i].aifs,
221				 mvmvif->deflink.queue_params[i].uapsd);
222
223	if (vif->type == NL80211_IFTYPE_STATION &&
224	    ap_sta_id != IWL_INVALID_STA) {
225		struct iwl_mvm_sta *mvm_sta;
226
227		mvm_sta = iwl_mvm_sta_from_staid_protected(mvm, ap_sta_id);
228		if (mvm_sta) {
229			pos += scnprintf(buf+pos, bufsz-pos,
230					 "ap_sta_id %d - reduced Tx power %d\n",
231					 ap_sta_id,
232					 mvm_sta->bt_reduced_txpower);
233		}
234	}
235
236	rcu_read_lock();
237	chanctx_conf = rcu_dereference(vif->bss_conf.chanctx_conf);
238	if (chanctx_conf)
239		pos += scnprintf(buf+pos, bufsz-pos,
240				 "idle rx chains %d, active rx chains: %d\n",
241				 chanctx_conf->rx_chains_static,
242				 chanctx_conf->rx_chains_dynamic);
243	rcu_read_unlock();
244
245	mutex_unlock(&mvm->mutex);
246
247	return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
248}
249
250static void iwl_dbgfs_update_bf(struct ieee80211_vif *vif,
251				enum iwl_dbgfs_bf_mask param, int value)
252{
253	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
254	struct iwl_dbgfs_bf *dbgfs_bf = &mvmvif->dbgfs_bf;
255
256	dbgfs_bf->mask |= param;
257
258	switch (param) {
259	case MVM_DEBUGFS_BF_ENERGY_DELTA:
260		dbgfs_bf->bf_energy_delta = value;
261		break;
262	case MVM_DEBUGFS_BF_ROAMING_ENERGY_DELTA:
263		dbgfs_bf->bf_roaming_energy_delta = value;
264		break;
265	case MVM_DEBUGFS_BF_ROAMING_STATE:
266		dbgfs_bf->bf_roaming_state = value;
267		break;
268	case MVM_DEBUGFS_BF_TEMP_THRESHOLD:
269		dbgfs_bf->bf_temp_threshold = value;
270		break;
271	case MVM_DEBUGFS_BF_TEMP_FAST_FILTER:
272		dbgfs_bf->bf_temp_fast_filter = value;
273		break;
274	case MVM_DEBUGFS_BF_TEMP_SLOW_FILTER:
275		dbgfs_bf->bf_temp_slow_filter = value;
276		break;
277	case MVM_DEBUGFS_BF_ENABLE_BEACON_FILTER:
278		dbgfs_bf->bf_enable_beacon_filter = value;
279		break;
280	case MVM_DEBUGFS_BF_DEBUG_FLAG:
281		dbgfs_bf->bf_debug_flag = value;
282		break;
283	case MVM_DEBUGFS_BF_ESCAPE_TIMER:
284		dbgfs_bf->bf_escape_timer = value;
285		break;
286	case MVM_DEBUGFS_BA_ENABLE_BEACON_ABORT:
287		dbgfs_bf->ba_enable_beacon_abort = value;
288		break;
289	case MVM_DEBUGFS_BA_ESCAPE_TIMER:
290		dbgfs_bf->ba_escape_timer = value;
291		break;
292	}
293}
294
295static ssize_t iwl_dbgfs_bf_params_write(struct ieee80211_vif *vif, char *buf,
296					 size_t count, loff_t *ppos)
297{
298	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
299	struct iwl_mvm *mvm = mvmvif->mvm;
300	enum iwl_dbgfs_bf_mask param;
301	int value, ret = 0;
302
303	if (!strncmp("bf_energy_delta=", buf, 16)) {
304		if (sscanf(buf+16, "%d", &value) != 1)
305			return -EINVAL;
306		if (value < IWL_BF_ENERGY_DELTA_MIN ||
307		    value > IWL_BF_ENERGY_DELTA_MAX)
308			return -EINVAL;
309		param = MVM_DEBUGFS_BF_ENERGY_DELTA;
310	} else if (!strncmp("bf_roaming_energy_delta=", buf, 24)) {
311		if (sscanf(buf+24, "%d", &value) != 1)
312			return -EINVAL;
313		if (value < IWL_BF_ROAMING_ENERGY_DELTA_MIN ||
314		    value > IWL_BF_ROAMING_ENERGY_DELTA_MAX)
315			return -EINVAL;
316		param = MVM_DEBUGFS_BF_ROAMING_ENERGY_DELTA;
317	} else if (!strncmp("bf_roaming_state=", buf, 17)) {
318		if (sscanf(buf+17, "%d", &value) != 1)
319			return -EINVAL;
320		if (value < IWL_BF_ROAMING_STATE_MIN ||
321		    value > IWL_BF_ROAMING_STATE_MAX)
322			return -EINVAL;
323		param = MVM_DEBUGFS_BF_ROAMING_STATE;
324	} else if (!strncmp("bf_temp_threshold=", buf, 18)) {
325		if (sscanf(buf+18, "%d", &value) != 1)
326			return -EINVAL;
327		if (value < IWL_BF_TEMP_THRESHOLD_MIN ||
328		    value > IWL_BF_TEMP_THRESHOLD_MAX)
329			return -EINVAL;
330		param = MVM_DEBUGFS_BF_TEMP_THRESHOLD;
331	} else if (!strncmp("bf_temp_fast_filter=", buf, 20)) {
332		if (sscanf(buf+20, "%d", &value) != 1)
333			return -EINVAL;
334		if (value < IWL_BF_TEMP_FAST_FILTER_MIN ||
335		    value > IWL_BF_TEMP_FAST_FILTER_MAX)
336			return -EINVAL;
337		param = MVM_DEBUGFS_BF_TEMP_FAST_FILTER;
338	} else if (!strncmp("bf_temp_slow_filter=", buf, 20)) {
339		if (sscanf(buf+20, "%d", &value) != 1)
340			return -EINVAL;
341		if (value < IWL_BF_TEMP_SLOW_FILTER_MIN ||
342		    value > IWL_BF_TEMP_SLOW_FILTER_MAX)
343			return -EINVAL;
344		param = MVM_DEBUGFS_BF_TEMP_SLOW_FILTER;
345	} else if (!strncmp("bf_enable_beacon_filter=", buf, 24)) {
346		if (sscanf(buf+24, "%d", &value) != 1)
347			return -EINVAL;
348		if (value < 0 || value > 1)
349			return -EINVAL;
350		param = MVM_DEBUGFS_BF_ENABLE_BEACON_FILTER;
351	} else if (!strncmp("bf_debug_flag=", buf, 14)) {
352		if (sscanf(buf+14, "%d", &value) != 1)
353			return -EINVAL;
354		if (value < 0 || value > 1)
355			return -EINVAL;
356		param = MVM_DEBUGFS_BF_DEBUG_FLAG;
357	} else if (!strncmp("bf_escape_timer=", buf, 16)) {
358		if (sscanf(buf+16, "%d", &value) != 1)
359			return -EINVAL;
360		if (value < IWL_BF_ESCAPE_TIMER_MIN ||
361		    value > IWL_BF_ESCAPE_TIMER_MAX)
362			return -EINVAL;
363		param = MVM_DEBUGFS_BF_ESCAPE_TIMER;
364	} else if (!strncmp("ba_escape_timer=", buf, 16)) {
365		if (sscanf(buf+16, "%d", &value) != 1)
366			return -EINVAL;
367		if (value < IWL_BA_ESCAPE_TIMER_MIN ||
368		    value > IWL_BA_ESCAPE_TIMER_MAX)
369			return -EINVAL;
370		param = MVM_DEBUGFS_BA_ESCAPE_TIMER;
371	} else if (!strncmp("ba_enable_beacon_abort=", buf, 23)) {
372		if (sscanf(buf+23, "%d", &value) != 1)
373			return -EINVAL;
374		if (value < 0 || value > 1)
375			return -EINVAL;
376		param = MVM_DEBUGFS_BA_ENABLE_BEACON_ABORT;
377	} else {
378		return -EINVAL;
379	}
380
381	mutex_lock(&mvm->mutex);
382	iwl_dbgfs_update_bf(vif, param, value);
383	if (param == MVM_DEBUGFS_BF_ENABLE_BEACON_FILTER && !value)
384		ret = iwl_mvm_disable_beacon_filter(mvm, vif);
385	else
386		ret = iwl_mvm_enable_beacon_filter(mvm, vif);
387	mutex_unlock(&mvm->mutex);
388
389	return ret ?: count;
390}
391
392static ssize_t iwl_dbgfs_bf_params_read(struct file *file,
393					char __user *user_buf,
394					size_t count, loff_t *ppos)
395{
396	struct ieee80211_vif *vif = file->private_data;
397	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
398	char buf[256];
399	int pos = 0;
400	const size_t bufsz = sizeof(buf);
401	struct iwl_beacon_filter_cmd cmd = {
402		IWL_BF_CMD_CONFIG_DEFAULTS,
403		.bf_enable_beacon_filter =
404			cpu_to_le32(IWL_BF_ENABLE_BEACON_FILTER_DEFAULT),
405		.ba_enable_beacon_abort =
406			cpu_to_le32(IWL_BA_ENABLE_BEACON_ABORT_DEFAULT),
407	};
408
409	iwl_mvm_beacon_filter_debugfs_parameters(vif, &cmd);
410	if (mvmvif->bf_enabled)
411		cmd.bf_enable_beacon_filter = cpu_to_le32(1);
412	else
413		cmd.bf_enable_beacon_filter = 0;
414
415	pos += scnprintf(buf+pos, bufsz-pos, "bf_energy_delta = %d\n",
416			 le32_to_cpu(cmd.bf_energy_delta));
417	pos += scnprintf(buf+pos, bufsz-pos, "bf_roaming_energy_delta = %d\n",
418			 le32_to_cpu(cmd.bf_roaming_energy_delta));
419	pos += scnprintf(buf+pos, bufsz-pos, "bf_roaming_state = %d\n",
420			 le32_to_cpu(cmd.bf_roaming_state));
421	pos += scnprintf(buf+pos, bufsz-pos, "bf_temp_threshold = %d\n",
422			 le32_to_cpu(cmd.bf_temp_threshold));
423	pos += scnprintf(buf+pos, bufsz-pos, "bf_temp_fast_filter = %d\n",
424			 le32_to_cpu(cmd.bf_temp_fast_filter));
425	pos += scnprintf(buf+pos, bufsz-pos, "bf_temp_slow_filter = %d\n",
426			 le32_to_cpu(cmd.bf_temp_slow_filter));
427	pos += scnprintf(buf+pos, bufsz-pos, "bf_enable_beacon_filter = %d\n",
428			 le32_to_cpu(cmd.bf_enable_beacon_filter));
429	pos += scnprintf(buf+pos, bufsz-pos, "bf_debug_flag = %d\n",
430			 le32_to_cpu(cmd.bf_debug_flag));
431	pos += scnprintf(buf+pos, bufsz-pos, "bf_escape_timer = %d\n",
432			 le32_to_cpu(cmd.bf_escape_timer));
433	pos += scnprintf(buf+pos, bufsz-pos, "ba_escape_timer = %d\n",
434			 le32_to_cpu(cmd.ba_escape_timer));
435	pos += scnprintf(buf+pos, bufsz-pos, "ba_enable_beacon_abort = %d\n",
436			 le32_to_cpu(cmd.ba_enable_beacon_abort));
437
438	return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
439}
440
441static ssize_t iwl_dbgfs_os_device_timediff_read(struct file *file,
442						 char __user *user_buf,
443						 size_t count, loff_t *ppos)
444{
445	struct ieee80211_vif *vif = file->private_data;
446	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
447	struct iwl_mvm *mvm = mvmvif->mvm;
448	u32 curr_gp2;
449	u64 curr_os;
450	s64 diff;
451	char buf[64];
452	const size_t bufsz = sizeof(buf);
453	int pos = 0;
454
455	mutex_lock(&mvm->mutex);
456	iwl_mvm_get_sync_time(mvm, CLOCK_BOOTTIME, &curr_gp2, &curr_os, NULL);
457	mutex_unlock(&mvm->mutex);
458
459	do_div(curr_os, NSEC_PER_USEC);
460	diff = curr_os - curr_gp2;
461	pos += scnprintf(buf + pos, bufsz - pos, "diff=%lld\n", diff);
462
463	return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
464}
465
466static ssize_t
467iwl_dbgfs_low_latency_write_handle(struct wiphy *wiphy, struct file *file,
468				   char *buf, size_t count, void *data)
469{
470	struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
471	struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
472	struct ieee80211_vif *vif = data;
473	u8 value;
474	int ret;
475
476	ret = kstrtou8(buf, 0, &value);
477	if (ret)
478		return ret;
479	if (value > 1)
480		return -EINVAL;
481
482	mutex_lock(&mvm->mutex);
483	iwl_mvm_update_low_latency(mvm, vif, value, LOW_LATENCY_DEBUGFS);
484	mutex_unlock(&mvm->mutex);
485
486	return count;
487}
488
489static ssize_t iwl_dbgfs_low_latency_write(struct file *file,
490					   const char __user *user_buf,
491					   size_t count, loff_t *ppos)
492{
493	struct ieee80211_vif *vif = file->private_data;
494	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
495	struct iwl_mvm *mvm = mvmvif->mvm;
496	char buf[10] = {};
497
498	return wiphy_locked_debugfs_write(mvm->hw->wiphy, file,
499					  buf, sizeof(buf), user_buf, count,
500					  iwl_dbgfs_low_latency_write_handle,
501					  vif);
502}
503
504static ssize_t
505iwl_dbgfs_low_latency_force_write_handle(struct wiphy *wiphy, struct file *file,
506					 char *buf, size_t count, void *data)
507{
508	struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
509	struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
510	struct ieee80211_vif *vif = data;
511	u8 value;
512	int ret;
513
514	ret = kstrtou8(buf, 0, &value);
515	if (ret)
516		return ret;
517
518	if (value > NUM_LOW_LATENCY_FORCE)
519		return -EINVAL;
520
521	mutex_lock(&mvm->mutex);
522	if (value == LOW_LATENCY_FORCE_UNSET) {
523		iwl_mvm_update_low_latency(mvm, vif, false,
524					   LOW_LATENCY_DEBUGFS_FORCE);
525		iwl_mvm_update_low_latency(mvm, vif, false,
526					   LOW_LATENCY_DEBUGFS_FORCE_ENABLE);
527	} else {
528		iwl_mvm_update_low_latency(mvm, vif,
529					   value == LOW_LATENCY_FORCE_ON,
530					   LOW_LATENCY_DEBUGFS_FORCE);
531		iwl_mvm_update_low_latency(mvm, vif, true,
532					   LOW_LATENCY_DEBUGFS_FORCE_ENABLE);
533	}
534	mutex_unlock(&mvm->mutex);
535	return count;
536}
537
538static ssize_t
539iwl_dbgfs_low_latency_force_write(struct file *file,
540				  const char __user *user_buf,
541				  size_t count, loff_t *ppos)
542{
543	struct ieee80211_vif *vif = file->private_data;
544	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
545	struct iwl_mvm *mvm = mvmvif->mvm;
546	char buf[10] = {};
547
548	return wiphy_locked_debugfs_write(mvm->hw->wiphy, file,
549					  buf, sizeof(buf), user_buf, count,
550					  iwl_dbgfs_low_latency_force_write_handle,
551					  vif);
552}
553
554static ssize_t iwl_dbgfs_low_latency_read(struct file *file,
555					  char __user *user_buf,
556					  size_t count, loff_t *ppos)
557{
558	struct ieee80211_vif *vif = file->private_data;
559	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
560	char format[] = "traffic=%d\ndbgfs=%d\nvcmd=%d\nvif_type=%d\n"
561			"dbgfs_force_enable=%d\ndbgfs_force=%d\nactual=%d\n";
562
563	/*
564	 * all values in format are boolean so the size of format is enough
565	 * for holding the result string
566	 */
567	char buf[sizeof(format) + 1] = {};
568	int len;
569
570	len = scnprintf(buf, sizeof(buf) - 1, format,
571			!!(mvmvif->low_latency & LOW_LATENCY_TRAFFIC),
572			!!(mvmvif->low_latency & LOW_LATENCY_DEBUGFS),
573			!!(mvmvif->low_latency & LOW_LATENCY_VCMD),
574			!!(mvmvif->low_latency & LOW_LATENCY_VIF_TYPE),
575			!!(mvmvif->low_latency &
576			   LOW_LATENCY_DEBUGFS_FORCE_ENABLE),
577			!!(mvmvif->low_latency & LOW_LATENCY_DEBUGFS_FORCE),
578			!!(mvmvif->low_latency_actual));
579	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
580}
581
582static ssize_t iwl_dbgfs_uapsd_misbehaving_read(struct file *file,
583						char __user *user_buf,
584						size_t count, loff_t *ppos)
585{
586	struct ieee80211_vif *vif = file->private_data;
587	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
588	char buf[20];
589	int len;
590
591	len = sprintf(buf, "%pM\n", mvmvif->uapsd_misbehaving_ap_addr);
592	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
593}
594
595static ssize_t iwl_dbgfs_uapsd_misbehaving_write(struct ieee80211_vif *vif,
596						 char *buf, size_t count,
597						 loff_t *ppos)
598{
599	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
600	struct iwl_mvm *mvm = mvmvif->mvm;
601	bool ret;
602
603	mutex_lock(&mvm->mutex);
604	ret = mac_pton(buf, mvmvif->uapsd_misbehaving_ap_addr);
605	mutex_unlock(&mvm->mutex);
606
607	return ret ? count : -EINVAL;
608}
609
610static ssize_t iwl_dbgfs_rx_phyinfo_write(struct ieee80211_vif *vif, char *buf,
611					  size_t count, loff_t *ppos)
612{
613	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
614	struct iwl_mvm *mvm = mvmvif->mvm;
615	struct ieee80211_bss_conf *link_conf;
616	u16 value;
617	int link_id, ret = -EINVAL;
618
619	ret = kstrtou16(buf, 0, &value);
620	if (ret)
621		return ret;
622
623	mutex_lock(&mvm->mutex);
624
625	mvm->dbgfs_rx_phyinfo = value;
626
627	for_each_vif_active_link(vif, link_conf, link_id) {
628		struct ieee80211_chanctx_conf *chanctx_conf;
629		struct cfg80211_chan_def min_def, ap_def;
630		struct iwl_mvm_phy_ctxt *phy_ctxt;
631		u8 chains_static, chains_dynamic;
632
633		rcu_read_lock();
634		chanctx_conf = rcu_dereference(link_conf->chanctx_conf);
635		if (!chanctx_conf) {
636			rcu_read_unlock();
637			continue;
638		}
639		/* A command can't be sent with RCU lock held, so copy
640		 * everything here and use it after unlocking
641		 */
642		min_def = chanctx_conf->min_def;
643		ap_def = chanctx_conf->ap;
644		chains_static = chanctx_conf->rx_chains_static;
645		chains_dynamic = chanctx_conf->rx_chains_dynamic;
646		rcu_read_unlock();
647
648		phy_ctxt = mvmvif->link[link_id]->phy_ctxt;
649		if (!phy_ctxt)
650			continue;
651
652		ret = iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, &min_def, &ap_def,
653					       chains_static, chains_dynamic);
654	}
655
656	mutex_unlock(&mvm->mutex);
657
658	return ret ?: count;
659}
660
661static ssize_t iwl_dbgfs_rx_phyinfo_read(struct file *file,
662					 char __user *user_buf,
663					 size_t count, loff_t *ppos)
664{
665	struct ieee80211_vif *vif = file->private_data;
666	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
667	char buf[8];
668	int len;
669
670	len = scnprintf(buf, sizeof(buf), "0x%04x\n",
671			mvmvif->mvm->dbgfs_rx_phyinfo);
672
673	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
674}
675
676static void iwl_dbgfs_quota_check(void *data, u8 *mac,
677				  struct ieee80211_vif *vif)
678{
679	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
680	int *ret = data;
681
682	if (mvmvif->dbgfs_quota_min)
683		*ret = -EINVAL;
684}
685
686static ssize_t iwl_dbgfs_quota_min_write(struct ieee80211_vif *vif, char *buf,
687					 size_t count, loff_t *ppos)
688{
689	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
690	struct iwl_mvm *mvm = mvmvif->mvm;
691	u16 value;
692	int ret;
693
694	ret = kstrtou16(buf, 0, &value);
695	if (ret)
696		return ret;
697
698	if (value > 95)
699		return -EINVAL;
700
701	mutex_lock(&mvm->mutex);
702
703	mvmvif->dbgfs_quota_min = 0;
704	ieee80211_iterate_interfaces(mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
705				     iwl_dbgfs_quota_check, &ret);
706	if (ret == 0) {
707		mvmvif->dbgfs_quota_min = value;
708		iwl_mvm_update_quotas(mvm, false, NULL);
709	}
710	mutex_unlock(&mvm->mutex);
711
712	return ret ?: count;
713}
714
715static ssize_t iwl_dbgfs_quota_min_read(struct file *file,
716					char __user *user_buf,
717					size_t count, loff_t *ppos)
718{
719	struct ieee80211_vif *vif = file->private_data;
720	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
721	char buf[10];
722	int len;
723
724	len = scnprintf(buf, sizeof(buf), "%d\n", mvmvif->dbgfs_quota_min);
725
726	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
727}
728
729static ssize_t iwl_dbgfs_max_tx_op_write(struct ieee80211_vif *vif, char *buf,
730					 size_t count, loff_t *ppos)
731{
732	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
733	struct iwl_mvm *mvm = mvmvif->mvm;
734	u16 value;
735	int ret;
736
737	ret = kstrtou16(buf, 0, &value);
738	if (ret)
739		return ret;
740
741	mutex_lock(&mvm->mutex);
742	mvmvif->max_tx_op = value;
743	mutex_unlock(&mvm->mutex);
744
745	return count;
746}
747
748static ssize_t iwl_dbgfs_max_tx_op_read(struct file *file,
749					char __user *user_buf,
750					size_t count, loff_t *ppos)
751{
752	struct ieee80211_vif *vif = file->private_data;
753	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
754	struct iwl_mvm *mvm = mvmvif->mvm;
755	char buf[10];
756	int len;
757
758	mutex_lock(&mvm->mutex);
759	len = scnprintf(buf, sizeof(buf), "%hu\n", mvmvif->max_tx_op);
760	mutex_unlock(&mvm->mutex);
761
762	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
763}
764
765#define MVM_DEBUGFS_WRITE_FILE_OPS(name, bufsz) \
766	_MVM_DEBUGFS_WRITE_FILE_OPS(name, bufsz, struct ieee80211_vif)
767#define MVM_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz) \
768	_MVM_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz, struct ieee80211_vif)
769#define MVM_DEBUGFS_ADD_FILE_VIF(name, parent, mode) do {		\
770		debugfs_create_file(#name, mode, parent, vif,		\
771				    &iwl_dbgfs_##name##_ops);		\
772	} while (0)
773
774MVM_DEBUGFS_READ_FILE_OPS(mac_params);
775MVM_DEBUGFS_READ_FILE_OPS(tx_pwr_lmt);
776MVM_DEBUGFS_READ_WRITE_FILE_OPS(pm_params, 32);
777MVM_DEBUGFS_READ_WRITE_FILE_OPS(bf_params, 256);
778
779static const struct file_operations iwl_dbgfs_low_latency_ops = {
780	.write = iwl_dbgfs_low_latency_write,
781	.read = iwl_dbgfs_low_latency_read,
782	.open = simple_open,
783	.llseek = generic_file_llseek,
784};
785
786static const struct file_operations iwl_dbgfs_low_latency_force_ops = {
787	.write = iwl_dbgfs_low_latency_force_write,
788	.open = simple_open,
789	.llseek = generic_file_llseek,
790};
791
792MVM_DEBUGFS_READ_WRITE_FILE_OPS(uapsd_misbehaving, 20);
793MVM_DEBUGFS_READ_WRITE_FILE_OPS(rx_phyinfo, 10);
794MVM_DEBUGFS_READ_WRITE_FILE_OPS(quota_min, 32);
795MVM_DEBUGFS_READ_FILE_OPS(os_device_timediff);
796MVM_DEBUGFS_READ_WRITE_FILE_OPS(max_tx_op, 10);
797
798void iwl_mvm_vif_add_debugfs(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
799{
800	struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
801	struct dentry *dbgfs_dir = vif->debugfs_dir;
802	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
803
804	mvmvif->dbgfs_dir = debugfs_create_dir("iwlmvm", dbgfs_dir);
805	if (IS_ERR_OR_NULL(mvmvif->dbgfs_dir)) {
806		IWL_ERR(mvm, "Failed to create debugfs directory under %pd\n",
807			dbgfs_dir);
808		return;
809	}
810
811	if (iwlmvm_mod_params.power_scheme != IWL_POWER_SCHEME_CAM &&
812	    ((vif->type == NL80211_IFTYPE_STATION && !vif->p2p) ||
813	     (vif->type == NL80211_IFTYPE_STATION && vif->p2p)))
814		MVM_DEBUGFS_ADD_FILE_VIF(pm_params, mvmvif->dbgfs_dir, 0600);
815
816	MVM_DEBUGFS_ADD_FILE_VIF(tx_pwr_lmt, mvmvif->dbgfs_dir, 0400);
817	MVM_DEBUGFS_ADD_FILE_VIF(mac_params, mvmvif->dbgfs_dir, 0400);
818	MVM_DEBUGFS_ADD_FILE_VIF(low_latency, mvmvif->dbgfs_dir, 0600);
819	MVM_DEBUGFS_ADD_FILE_VIF(low_latency_force, mvmvif->dbgfs_dir, 0600);
820	MVM_DEBUGFS_ADD_FILE_VIF(uapsd_misbehaving, mvmvif->dbgfs_dir, 0600);
821	MVM_DEBUGFS_ADD_FILE_VIF(rx_phyinfo, mvmvif->dbgfs_dir, 0600);
822	MVM_DEBUGFS_ADD_FILE_VIF(quota_min, mvmvif->dbgfs_dir, 0600);
823	MVM_DEBUGFS_ADD_FILE_VIF(os_device_timediff, mvmvif->dbgfs_dir, 0400);
824	MVM_DEBUGFS_ADD_FILE_VIF(max_tx_op, mvmvif->dbgfs_dir, 0600);
825	debugfs_create_bool("ftm_unprotected", 0200, mvmvif->dbgfs_dir,
826			    &mvmvif->ftm_unprotected);
827
828	if (vif->type == NL80211_IFTYPE_STATION && !vif->p2p &&
829	    mvmvif == mvm->bf_allowed_vif)
830		MVM_DEBUGFS_ADD_FILE_VIF(bf_params, mvmvif->dbgfs_dir, 0600);
831}
832
833void iwl_mvm_vif_dbgfs_add_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
834{
835	struct dentry *dbgfs_dir = vif->debugfs_dir;
836	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
837	char buf[3 * 3 + 11 + (NL80211_WIPHY_NAME_MAXLEN + 1) +
838		 (7 + IFNAMSIZ + 1) + 6 + 1];
839	char name[7 + IFNAMSIZ + 1];
840
841	/* this will happen in monitor mode */
842	if (!dbgfs_dir)
843		return;
844
845	/*
846	 * Create symlink for convenience pointing to interface specific
847	 * debugfs entries for the driver. For example, under
848	 * /sys/kernel/debug/iwlwifi/0000\:02\:00.0/iwlmvm/
849	 * find
850	 * netdev:wlan0 -> ../../../ieee80211/phy0/netdev:wlan0/iwlmvm/
851	 */
852	snprintf(name, sizeof(name), "%pd", dbgfs_dir);
853	snprintf(buf, sizeof(buf), "../../../%pd3/iwlmvm", dbgfs_dir);
854
855	mvmvif->dbgfs_slink =
856		debugfs_create_symlink(name, mvm->debugfs_dir, buf);
857}
858
859void iwl_mvm_vif_dbgfs_rm_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
860{
861	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
862
863	debugfs_remove(mvmvif->dbgfs_slink);
864	mvmvif->dbgfs_slink = NULL;
865}
866
867#define MVM_DEBUGFS_WRITE_LINK_FILE_OPS(name, bufsz)			\
868	_MVM_DEBUGFS_WRITE_FILE_OPS(link_##name, bufsz,			\
869				    struct ieee80211_bss_conf)
870#define MVM_DEBUGFS_READ_WRITE_LINK_FILE_OPS(name, bufsz)		\
871	_MVM_DEBUGFS_READ_WRITE_FILE_OPS(link_##name, bufsz,		\
872					 struct ieee80211_bss_conf)
873#define MVM_DEBUGFS_ADD_LINK_FILE(name, parent, mode)			\
874	debugfs_create_file(#name, mode, parent, link_conf,		\
875			    &iwl_dbgfs_link_##name##_ops)
876
877static void iwl_mvm_debugfs_add_link_files(struct ieee80211_vif *vif,
878					   struct ieee80211_bss_conf *link_conf,
879					   struct dentry *mvm_dir)
880{
881	/* Add per-link files here*/
882}
883
884void iwl_mvm_link_add_debugfs(struct ieee80211_hw *hw,
885			      struct ieee80211_vif *vif,
886			      struct ieee80211_bss_conf *link_conf,
887			      struct dentry *dir)
888{
889	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
890	struct iwl_mvm *mvm = mvmvif->mvm;
891	unsigned int link_id = link_conf->link_id;
892	struct iwl_mvm_vif_link_info *link_info = mvmvif->link[link_id];
893	struct dentry *mvm_dir;
894
895	if (WARN_ON(!link_info) || !dir)
896		return;
897
898	if (dir == vif->debugfs_dir) {
899		WARN_ON(!mvmvif->dbgfs_dir);
900		mvm_dir = mvmvif->dbgfs_dir;
901	} else {
902		mvm_dir = debugfs_create_dir("iwlmvm", dir);
903		if (IS_ERR_OR_NULL(mvm_dir)) {
904			IWL_ERR(mvm, "Failed to create debugfs directory under %pd\n",
905				dir);
906			return;
907		}
908	}
909
910	iwl_mvm_debugfs_add_link_files(vif, link_conf, mvm_dir);
911}