debugfs_netdev.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright (c) 2006	Jiri Benc <jbenc@suse.cz>
   4 * Copyright 2007	Johannes Berg <johannes@sipsolutions.net>
   5 * Copyright (C) 2020-2023 Intel Corporation
   6 */
   7
   8#include <linux/kernel.h>
   9#include <linux/device.h>
  10#include <linux/if.h>
  11#include <linux/if_ether.h>
  12#include <linux/interrupt.h>
  13#include <linux/netdevice.h>
  14#include <linux/rtnetlink.h>
  15#include <linux/slab.h>
  16#include <linux/notifier.h>
  17#include <net/mac80211.h>
  18#include <net/cfg80211.h>
  19#include "ieee80211_i.h"
  20#include "rate.h"
  21#include "debugfs.h"
  22#include "debugfs_netdev.h"
  23#include "driver-ops.h"
  24
  25struct ieee80211_if_read_sdata_data {
  26	ssize_t (*format)(const struct ieee80211_sub_if_data *, char *, int);
  27	struct ieee80211_sub_if_data *sdata;
  28};
  29
  30static ssize_t ieee80211_if_read_sdata_handler(struct wiphy *wiphy,
  31					       struct file *file,
  32					       char *buf,
  33					       size_t bufsize,
  34					       void *data)
  35{
  36	struct ieee80211_if_read_sdata_data *d = data;
  37
  38	return d->format(d->sdata, buf, bufsize);
  39}
  40
  41static ssize_t ieee80211_if_read_sdata(
  42	struct file *file,
  43	char __user *userbuf,
  44	size_t count, loff_t *ppos,
  45	ssize_t (*format)(const struct ieee80211_sub_if_data *sdata, char *, int))
  46{
  47	struct ieee80211_sub_if_data *sdata = file->private_data;
  48	struct ieee80211_if_read_sdata_data data = {
  49		.format = format,
  50		.sdata = sdata,
  51	};
  52	char buf[200];
  53
  54	return wiphy_locked_debugfs_read(sdata->local->hw.wiphy,
  55					 file, buf, sizeof(buf),
  56					 userbuf, count, ppos,
  57					 ieee80211_if_read_sdata_handler,
  58					 &data);
  59}
  60
  61struct ieee80211_if_write_sdata_data {
  62	ssize_t (*write)(struct ieee80211_sub_if_data *, const char *, int);
  63	struct ieee80211_sub_if_data *sdata;
  64};
  65
  66static ssize_t ieee80211_if_write_sdata_handler(struct wiphy *wiphy,
  67						struct file *file,
  68						char *buf,
  69						size_t count,
  70						void *data)
  71{
  72	struct ieee80211_if_write_sdata_data *d = data;
  73
  74	return d->write(d->sdata, buf, count);
  75}
  76
  77static ssize_t ieee80211_if_write_sdata(
  78	struct file *file,
  79	const char __user *userbuf,
  80	size_t count, loff_t *ppos,
  81	ssize_t (*write)(struct ieee80211_sub_if_data *sdata, const char *, int))
  82{
  83	struct ieee80211_sub_if_data *sdata = file->private_data;
  84	struct ieee80211_if_write_sdata_data data = {
  85		.write = write,
  86		.sdata = sdata,
  87	};
  88	char buf[64];
  89
  90	return wiphy_locked_debugfs_write(sdata->local->hw.wiphy,
  91					  file, buf, sizeof(buf),
  92					  userbuf, count,
  93					  ieee80211_if_write_sdata_handler,
  94					  &data);
  95}
  96
  97struct ieee80211_if_read_link_data {
  98	ssize_t (*format)(const struct ieee80211_link_data *, char *, int);
  99	struct ieee80211_link_data *link;
 100};
 101
 102static ssize_t ieee80211_if_read_link_handler(struct wiphy *wiphy,
 103					      struct file *file,
 104					      char *buf,
 105					      size_t bufsize,
 106					      void *data)
 107{
 108	struct ieee80211_if_read_link_data *d = data;
 109
 110	return d->format(d->link, buf, bufsize);
 111}
 112
 113static ssize_t ieee80211_if_read_link(
 114	struct file *file,
 115	char __user *userbuf,
 116	size_t count, loff_t *ppos,
 117	ssize_t (*format)(const struct ieee80211_link_data *link, char *, int))
 118{
 119	struct ieee80211_link_data *link = file->private_data;
 120	struct ieee80211_if_read_link_data data = {
 121		.format = format,
 122		.link = link,
 123	};
 124	char buf[200];
 125
 126	return wiphy_locked_debugfs_read(link->sdata->local->hw.wiphy,
 127					 file, buf, sizeof(buf),
 128					 userbuf, count, ppos,
 129					 ieee80211_if_read_link_handler,
 130					 &data);
 131}
 132
 133struct ieee80211_if_write_link_data {
 134	ssize_t (*write)(struct ieee80211_link_data *, const char *, int);
 135	struct ieee80211_link_data *link;
 136};
 137
 138static ssize_t ieee80211_if_write_link_handler(struct wiphy *wiphy,
 139					       struct file *file,
 140					       char *buf,
 141					       size_t count,
 142					       void *data)
 143{
 144	struct ieee80211_if_write_sdata_data *d = data;
 145
 146	return d->write(d->sdata, buf, count);
 147}
 148
 149static ssize_t ieee80211_if_write_link(
 150	struct file *file,
 151	const char __user *userbuf,
 152	size_t count, loff_t *ppos,
 153	ssize_t (*write)(struct ieee80211_link_data *link, const char *, int))
 154{
 155	struct ieee80211_link_data *link = file->private_data;
 156	struct ieee80211_if_write_link_data data = {
 157		.write = write,
 158		.link = link,
 159	};
 160	char buf[64];
 161
 162	return wiphy_locked_debugfs_write(link->sdata->local->hw.wiphy,
 163					  file, buf, sizeof(buf),
 164					  userbuf, count,
 165					  ieee80211_if_write_link_handler,
 166					  &data);
 167}
 168
 169#define IEEE80211_IF_FMT(name, type, field, format_string)		\
 170static ssize_t ieee80211_if_fmt_##name(					\
 171	const type *data, char *buf,					\
 172	int buflen)							\
 173{									\
 174	return scnprintf(buf, buflen, format_string, data->field);	\
 175}
 176#define IEEE80211_IF_FMT_DEC(name, type, field)				\
 177		IEEE80211_IF_FMT(name, type, field, "%d\n")
 178#define IEEE80211_IF_FMT_HEX(name, type, field)				\
 179		IEEE80211_IF_FMT(name, type, field, "%#x\n")
 180#define IEEE80211_IF_FMT_LHEX(name, type, field)			\
 181		IEEE80211_IF_FMT(name, type, field, "%#lx\n")
 182
 183#define IEEE80211_IF_FMT_HEXARRAY(name, type, field)			\
 184static ssize_t ieee80211_if_fmt_##name(					\
 185	const type *data,						\
 186	char *buf, int buflen)						\
 187{									\
 188	char *p = buf;							\
 189	int i;								\
 190	for (i = 0; i < sizeof(data->field); i++) {			\
 191		p += scnprintf(p, buflen + buf - p, "%.2x ",		\
 192				 data->field[i]);			\
 193	}								\
 194	p += scnprintf(p, buflen + buf - p, "\n");			\
 195	return p - buf;							\
 196}
 197
 198#define IEEE80211_IF_FMT_ATOMIC(name, type, field)			\
 199static ssize_t ieee80211_if_fmt_##name(					\
 200	const type *data,						\
 201	char *buf, int buflen)						\
 202{									\
 203	return scnprintf(buf, buflen, "%d\n", atomic_read(&data->field));\
 204}
 205
 206#define IEEE80211_IF_FMT_MAC(name, type, field)				\
 207static ssize_t ieee80211_if_fmt_##name(					\
 208	const type *data, char *buf,					\
 209	int buflen)							\
 210{									\
 211	return scnprintf(buf, buflen, "%pM\n", data->field);		\
 212}
 213
 214#define IEEE80211_IF_FMT_JIFFIES_TO_MS(name, type, field)		\
 215static ssize_t ieee80211_if_fmt_##name(					\
 216	const type *data,						\
 217	char *buf, int buflen)						\
 218{									\
 219	return scnprintf(buf, buflen, "%d\n",				\
 220			 jiffies_to_msecs(data->field));		\
 221}
 222
 223#define _IEEE80211_IF_FILE_OPS(name, _read, _write)			\
 224static const struct debugfs_short_fops name##_ops = {				\
 225	.read = (_read),						\
 226	.write = (_write),						\
 227	.llseek = generic_file_llseek,					\
 228}
 229
 230#define _IEEE80211_IF_FILE_R_FN(name)					\
 231static ssize_t ieee80211_if_read_##name(struct file *file,		\
 232					char __user *userbuf,		\
 233					size_t count, loff_t *ppos)	\
 234{									\
 235	return ieee80211_if_read_sdata(file,				\
 236				       userbuf, count, ppos,		\
 237				       ieee80211_if_fmt_##name);	\
 238}
 239
 240#define _IEEE80211_IF_FILE_W_FN(name)					\
 241static ssize_t ieee80211_if_write_##name(struct file *file,		\
 242					 const char __user *userbuf,	\
 243					 size_t count, loff_t *ppos)	\
 244{									\
 245	return ieee80211_if_write_sdata(file, userbuf,			\
 246					count, ppos,			\
 247					ieee80211_if_parse_##name);	\
 248}
 249
 250#define IEEE80211_IF_FILE_R(name)					\
 251	_IEEE80211_IF_FILE_R_FN(name)					\
 252	_IEEE80211_IF_FILE_OPS(name, ieee80211_if_read_##name, NULL)
 253
 254#define IEEE80211_IF_FILE_W(name)					\
 255	_IEEE80211_IF_FILE_W_FN(name)					\
 256	_IEEE80211_IF_FILE_OPS(name, NULL, ieee80211_if_write_##name)
 257
 258#define IEEE80211_IF_FILE_RW(name)					\
 259	_IEEE80211_IF_FILE_R_FN(name)					\
 260	_IEEE80211_IF_FILE_W_FN(name)					\
 261	_IEEE80211_IF_FILE_OPS(name, ieee80211_if_read_##name,		\
 262			       ieee80211_if_write_##name)
 263
 264#define IEEE80211_IF_FILE(name, field, format)				\
 265	IEEE80211_IF_FMT_##format(name, struct ieee80211_sub_if_data, field) \
 266	IEEE80211_IF_FILE_R(name)
 267
 268#define _IEEE80211_IF_LINK_R_FN(name)					\
 269static ssize_t ieee80211_if_read_##name(struct file *file,		\
 270					char __user *userbuf,		\
 271					size_t count, loff_t *ppos)	\
 272{									\
 273	return ieee80211_if_read_link(file,				\
 274				      userbuf, count, ppos,		\
 275				      ieee80211_if_fmt_##name);	\
 276}
 277
 278#define _IEEE80211_IF_LINK_W_FN(name)					\
 279static ssize_t ieee80211_if_write_##name(struct file *file,		\
 280					 const char __user *userbuf,	\
 281					 size_t count, loff_t *ppos)	\
 282{									\
 283	return ieee80211_if_write_link(file, userbuf,			\
 284				       count, ppos,			\
 285				       ieee80211_if_parse_##name);	\
 286}
 287
 288#define IEEE80211_IF_LINK_FILE_R(name)					\
 289	_IEEE80211_IF_LINK_R_FN(name)					\
 290	_IEEE80211_IF_FILE_OPS(link_##name, ieee80211_if_read_##name, NULL)
 291
 292#define IEEE80211_IF_LINK_FILE_W(name)					\
 293	_IEEE80211_IF_LINK_W_FN(name)					\
 294	_IEEE80211_IF_FILE_OPS(link_##name, NULL, ieee80211_if_write_##name)
 295
 296#define IEEE80211_IF_LINK_FILE_RW(name)					\
 297	_IEEE80211_IF_LINK_R_FN(name)					\
 298	_IEEE80211_IF_LINK_W_FN(name)					\
 299	_IEEE80211_IF_FILE_OPS(link_##name, ieee80211_if_read_##name,	\
 300			       ieee80211_if_write_##name)
 301
 302#define IEEE80211_IF_LINK_FILE(name, field, format)				\
 303	IEEE80211_IF_FMT_##format(name, struct ieee80211_link_data, field) \
 304	IEEE80211_IF_LINK_FILE_R(name)
 305
 306/* common attributes */
 307IEEE80211_IF_FILE(rc_rateidx_mask_2ghz, rc_rateidx_mask[NL80211_BAND_2GHZ],
 308		  HEX);
 309IEEE80211_IF_FILE(rc_rateidx_mask_5ghz, rc_rateidx_mask[NL80211_BAND_5GHZ],
 310		  HEX);
 311IEEE80211_IF_FILE(rc_rateidx_mcs_mask_2ghz,
 312		  rc_rateidx_mcs_mask[NL80211_BAND_2GHZ], HEXARRAY);
 313IEEE80211_IF_FILE(rc_rateidx_mcs_mask_5ghz,
 314		  rc_rateidx_mcs_mask[NL80211_BAND_5GHZ], HEXARRAY);
 315
 316static ssize_t ieee80211_if_fmt_rc_rateidx_vht_mcs_mask_2ghz(
 317				const struct ieee80211_sub_if_data *sdata,
 318				char *buf, int buflen)
 319{
 320	int i, len = 0;
 321	const u16 *mask = sdata->rc_rateidx_vht_mcs_mask[NL80211_BAND_2GHZ];
 322
 323	for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
 324		len += scnprintf(buf + len, buflen - len, "%04x ", mask[i]);
 325	len += scnprintf(buf + len, buflen - len, "\n");
 326
 327	return len;
 328}
 329
 330IEEE80211_IF_FILE_R(rc_rateidx_vht_mcs_mask_2ghz);
 331
 332static ssize_t ieee80211_if_fmt_rc_rateidx_vht_mcs_mask_5ghz(
 333				const struct ieee80211_sub_if_data *sdata,
 334				char *buf, int buflen)
 335{
 336	int i, len = 0;
 337	const u16 *mask = sdata->rc_rateidx_vht_mcs_mask[NL80211_BAND_5GHZ];
 338
 339	for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
 340		len += scnprintf(buf + len, buflen - len, "%04x ", mask[i]);
 341	len += scnprintf(buf + len, buflen - len, "\n");
 342
 343	return len;
 344}
 345
 346IEEE80211_IF_FILE_R(rc_rateidx_vht_mcs_mask_5ghz);
 347
 348IEEE80211_IF_FILE(flags, flags, HEX);
 349IEEE80211_IF_FILE(state, state, LHEX);
 350IEEE80211_IF_LINK_FILE(txpower, conf->txpower, DEC);
 351IEEE80211_IF_LINK_FILE(ap_power_level, ap_power_level, DEC);
 352IEEE80211_IF_LINK_FILE(user_power_level, user_power_level, DEC);
 353
 354static ssize_t
 355ieee80211_if_fmt_hw_queues(const struct ieee80211_sub_if_data *sdata,
 356			   char *buf, int buflen)
 357{
 358	int len;
 359
 360	len = scnprintf(buf, buflen, "AC queues: VO:%d VI:%d BE:%d BK:%d\n",
 361			sdata->vif.hw_queue[IEEE80211_AC_VO],
 362			sdata->vif.hw_queue[IEEE80211_AC_VI],
 363			sdata->vif.hw_queue[IEEE80211_AC_BE],
 364			sdata->vif.hw_queue[IEEE80211_AC_BK]);
 365
 366	if (sdata->vif.type == NL80211_IFTYPE_AP)
 367		len += scnprintf(buf + len, buflen - len, "cab queue: %d\n",
 368				 sdata->vif.cab_queue);
 369
 370	return len;
 371}
 372IEEE80211_IF_FILE_R(hw_queues);
 373
 374/* STA attributes */
 375IEEE80211_IF_FILE(bssid, deflink.u.mgd.bssid, MAC);
 376IEEE80211_IF_FILE(aid, vif.cfg.aid, DEC);
 377IEEE80211_IF_FILE(beacon_timeout, u.mgd.beacon_timeout, JIFFIES_TO_MS);
 378
 379static int ieee80211_set_smps(struct ieee80211_link_data *link,
 380			      enum ieee80211_smps_mode smps_mode)
 381{
 382	struct ieee80211_sub_if_data *sdata = link->sdata;
 383	struct ieee80211_local *local = sdata->local;
 384
 385	/* The driver indicated that EML is enabled for the interface, thus do
 386	 * not allow to override the SMPS state.
 387	 */
 388	if (sdata->vif.driver_flags & IEEE80211_VIF_EML_ACTIVE)
 389		return -EOPNOTSUPP;
 390
 391	if (!(local->hw.wiphy->features & NL80211_FEATURE_STATIC_SMPS) &&
 392	    smps_mode == IEEE80211_SMPS_STATIC)
 393		return -EINVAL;
 394
 395	/* auto should be dynamic if in PS mode */
 396	if (!(local->hw.wiphy->features & NL80211_FEATURE_DYNAMIC_SMPS) &&
 397	    (smps_mode == IEEE80211_SMPS_DYNAMIC ||
 398	     smps_mode == IEEE80211_SMPS_AUTOMATIC))
 399		return -EINVAL;
 400
 401	if (sdata->vif.type != NL80211_IFTYPE_STATION)
 402		return -EOPNOTSUPP;
 403
 404	return __ieee80211_request_smps_mgd(link->sdata, link, smps_mode);
 405}
 406
 407static const char *smps_modes[IEEE80211_SMPS_NUM_MODES] = {
 408	[IEEE80211_SMPS_AUTOMATIC] = "auto",
 409	[IEEE80211_SMPS_OFF] = "off",
 410	[IEEE80211_SMPS_STATIC] = "static",
 411	[IEEE80211_SMPS_DYNAMIC] = "dynamic",
 412};
 413
 414static ssize_t ieee80211_if_fmt_smps(const struct ieee80211_link_data *link,
 415				     char *buf, int buflen)
 416{
 417	if (link->sdata->vif.type == NL80211_IFTYPE_STATION)
 418		return snprintf(buf, buflen, "request: %s\nused: %s\n",
 419				smps_modes[link->u.mgd.req_smps],
 420				smps_modes[link->smps_mode]);
 421	return -EINVAL;
 422}
 423
 424static ssize_t ieee80211_if_parse_smps(struct ieee80211_link_data *link,
 425				       const char *buf, int buflen)
 426{
 427	enum ieee80211_smps_mode mode;
 428
 429	for (mode = 0; mode < IEEE80211_SMPS_NUM_MODES; mode++) {
 430		if (strncmp(buf, smps_modes[mode], buflen) == 0) {
 431			int err = ieee80211_set_smps(link, mode);
 432			if (!err)
 433				return buflen;
 434			return err;
 435		}
 436	}
 437
 438	return -EINVAL;
 439}
 440IEEE80211_IF_LINK_FILE_RW(smps);
 441
 442static ssize_t ieee80211_if_parse_tkip_mic_test(
 443	struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
 444{
 445	struct ieee80211_local *local = sdata->local;
 446	u8 addr[ETH_ALEN];
 447	struct sk_buff *skb;
 448	struct ieee80211_hdr *hdr;
 449	__le16 fc;
 450
 451	if (!mac_pton(buf, addr))
 452		return -EINVAL;
 453
 454	if (!ieee80211_sdata_running(sdata))
 455		return -ENOTCONN;
 456
 457	skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24 + 100);
 458	if (!skb)
 459		return -ENOMEM;
 460	skb_reserve(skb, local->hw.extra_tx_headroom);
 461
 462	hdr = skb_put_zero(skb, 24);
 463	fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA);
 464
 465	switch (sdata->vif.type) {
 466	case NL80211_IFTYPE_AP:
 467		fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
 468		/* DA BSSID SA */
 469		memcpy(hdr->addr1, addr, ETH_ALEN);
 470		memcpy(hdr->addr2, sdata->vif.addr, ETH_ALEN);
 471		memcpy(hdr->addr3, sdata->vif.addr, ETH_ALEN);
 472		break;
 473	case NL80211_IFTYPE_STATION:
 474		fc |= cpu_to_le16(IEEE80211_FCTL_TODS);
 475		/* BSSID SA DA */
 476		if (!sdata->u.mgd.associated) {
 477			dev_kfree_skb(skb);
 478			return -ENOTCONN;
 479		}
 480		memcpy(hdr->addr1, sdata->deflink.u.mgd.bssid, ETH_ALEN);
 481		memcpy(hdr->addr2, sdata->vif.addr, ETH_ALEN);
 482		memcpy(hdr->addr3, addr, ETH_ALEN);
 483		break;
 484	default:
 485		dev_kfree_skb(skb);
 486		return -EOPNOTSUPP;
 487	}
 488	hdr->frame_control = fc;
 489
 490	/*
 491	 * Add some length to the test frame to make it look bit more valid.
 492	 * The exact contents does not matter since the recipient is required
 493	 * to drop this because of the Michael MIC failure.
 494	 */
 495	skb_put_zero(skb, 50);
 496
 497	IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_TKIP_MIC_FAILURE;
 498
 499	ieee80211_tx_skb(sdata, skb);
 500
 501	return buflen;
 502}
 503IEEE80211_IF_FILE_W(tkip_mic_test);
 504
 505static ssize_t ieee80211_if_parse_beacon_loss(
 506	struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
 507{
 508	if (!ieee80211_sdata_running(sdata) || !sdata->vif.cfg.assoc)
 509		return -ENOTCONN;
 510
 511	ieee80211_beacon_loss(&sdata->vif);
 512
 513	return buflen;
 514}
 515IEEE80211_IF_FILE_W(beacon_loss);
 516
 517static ssize_t ieee80211_if_fmt_uapsd_queues(
 518	const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
 519{
 520	const struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 521
 522	return snprintf(buf, buflen, "0x%x\n", ifmgd->uapsd_queues);
 523}
 524
 525static ssize_t ieee80211_if_parse_uapsd_queues(
 526	struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
 527{
 528	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 529	u8 val;
 530	int ret;
 531
 532	ret = kstrtou8(buf, 0, &val);
 533	if (ret)
 534		return ret;
 535
 536	if (val & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
 537		return -ERANGE;
 538
 539	ifmgd->uapsd_queues = val;
 540
 541	return buflen;
 542}
 543IEEE80211_IF_FILE_RW(uapsd_queues);
 544
 545static ssize_t ieee80211_if_fmt_uapsd_max_sp_len(
 546	const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
 547{
 548	const struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 549
 550	return snprintf(buf, buflen, "0x%x\n", ifmgd->uapsd_max_sp_len);
 551}
 552
 553static ssize_t ieee80211_if_parse_uapsd_max_sp_len(
 554	struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
 555{
 556	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 557	unsigned long val;
 558	int ret;
 559
 560	ret = kstrtoul(buf, 0, &val);
 561	if (ret)
 562		return -EINVAL;
 563
 564	if (val & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
 565		return -ERANGE;
 566
 567	ifmgd->uapsd_max_sp_len = val;
 568
 569	return buflen;
 570}
 571IEEE80211_IF_FILE_RW(uapsd_max_sp_len);
 572
 573static ssize_t ieee80211_if_fmt_tdls_wider_bw(
 574	const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
 575{
 576	const struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 577	bool tdls_wider_bw;
 578
 579	tdls_wider_bw = ieee80211_hw_check(&sdata->local->hw, TDLS_WIDER_BW) &&
 580			!ifmgd->tdls_wider_bw_prohibited;
 581
 582	return snprintf(buf, buflen, "%d\n", tdls_wider_bw);
 583}
 584
 585static ssize_t ieee80211_if_parse_tdls_wider_bw(
 586	struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
 587{
 588	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 589	u8 val;
 590	int ret;
 591
 592	ret = kstrtou8(buf, 0, &val);
 593	if (ret)
 594		return ret;
 595
 596	ifmgd->tdls_wider_bw_prohibited = !val;
 597	return buflen;
 598}
 599IEEE80211_IF_FILE_RW(tdls_wider_bw);
 600
 601/* AP attributes */
 602IEEE80211_IF_FILE(num_mcast_sta, u.ap.num_mcast_sta, ATOMIC);
 603IEEE80211_IF_FILE(num_sta_ps, u.ap.ps.num_sta_ps, ATOMIC);
 604IEEE80211_IF_FILE(dtim_count, u.ap.ps.dtim_count, DEC);
 605IEEE80211_IF_FILE(num_mcast_sta_vlan, u.vlan.num_mcast_sta, ATOMIC);
 606
 607static ssize_t ieee80211_if_fmt_num_buffered_multicast(
 608	const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
 609{
 610	return scnprintf(buf, buflen, "%u\n",
 611			 skb_queue_len(&sdata->u.ap.ps.bc_buf));
 612}
 613IEEE80211_IF_FILE_R(num_buffered_multicast);
 614
 615static ssize_t ieee80211_if_fmt_aqm(
 616	const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
 617{
 618	struct ieee80211_local *local = sdata->local;
 619	struct txq_info *txqi;
 620	int len;
 621
 622	if (!sdata->vif.txq)
 623		return 0;
 624
 625	txqi = to_txq_info(sdata->vif.txq);
 626
 627	spin_lock_bh(&local->fq.lock);
 628
 629	len = scnprintf(buf,
 630			buflen,
 631			"ac backlog-bytes backlog-packets new-flows drops marks overlimit collisions tx-bytes tx-packets\n"
 632			"%u %u %u %u %u %u %u %u %u %u\n",
 633			txqi->txq.ac,
 634			txqi->tin.backlog_bytes,
 635			txqi->tin.backlog_packets,
 636			txqi->tin.flows,
 637			txqi->cstats.drop_count,
 638			txqi->cstats.ecn_mark,
 639			txqi->tin.overlimit,
 640			txqi->tin.collisions,
 641			txqi->tin.tx_bytes,
 642			txqi->tin.tx_packets);
 643
 644	spin_unlock_bh(&local->fq.lock);
 645
 646	return len;
 647}
 648IEEE80211_IF_FILE_R(aqm);
 649
 650IEEE80211_IF_FILE(multicast_to_unicast, u.ap.multicast_to_unicast, HEX);
 651
 652/* IBSS attributes */
 653static ssize_t ieee80211_if_fmt_tsf(
 654	const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
 655{
 656	struct ieee80211_local *local = sdata->local;
 657	u64 tsf;
 658
 659	tsf = drv_get_tsf(local, (struct ieee80211_sub_if_data *)sdata);
 660
 661	return scnprintf(buf, buflen, "0x%016llx\n", (unsigned long long) tsf);
 662}
 663
 664static ssize_t ieee80211_if_parse_tsf(
 665	struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
 666{
 667	struct ieee80211_local *local = sdata->local;
 668	unsigned long long tsf;
 669	int ret;
 670	int tsf_is_delta = 0;
 671
 672	if (strncmp(buf, "reset", 5) == 0) {
 673		if (local->ops->reset_tsf) {
 674			drv_reset_tsf(local, sdata);
 675			wiphy_info(local->hw.wiphy, "debugfs reset TSF\n");
 676		}
 677	} else {
 678		if (buflen > 10 && buf[1] == '=') {
 679			if (buf[0] == '+')
 680				tsf_is_delta = 1;
 681			else if (buf[0] == '-')
 682				tsf_is_delta = -1;
 683			else
 684				return -EINVAL;
 685			buf += 2;
 686		}
 687		ret = kstrtoull(buf, 10, &tsf);
 688		if (ret < 0)
 689			return ret;
 690		if (tsf_is_delta && local->ops->offset_tsf) {
 691			drv_offset_tsf(local, sdata, tsf_is_delta * tsf);
 692			wiphy_info(local->hw.wiphy,
 693				   "debugfs offset TSF by %018lld\n",
 694				   tsf_is_delta * tsf);
 695		} else if (local->ops->set_tsf) {
 696			if (tsf_is_delta)
 697				tsf = drv_get_tsf(local, sdata) +
 698				      tsf_is_delta * tsf;
 699			drv_set_tsf(local, sdata, tsf);
 700			wiphy_info(local->hw.wiphy,
 701				   "debugfs set TSF to %#018llx\n", tsf);
 702		}
 703	}
 704
 705	ieee80211_recalc_dtim(sdata, drv_get_tsf(local, sdata));
 706	return buflen;
 707}
 708IEEE80211_IF_FILE_RW(tsf);
 709
 710static ssize_t ieee80211_if_fmt_valid_links(const struct ieee80211_sub_if_data *sdata,
 711					    char *buf, int buflen)
 712{
 713	return snprintf(buf, buflen, "0x%x\n", sdata->vif.valid_links);
 714}
 715IEEE80211_IF_FILE_R(valid_links);
 716
 717static ssize_t ieee80211_if_fmt_active_links(const struct ieee80211_sub_if_data *sdata,
 718					     char *buf, int buflen)
 719{
 720	return snprintf(buf, buflen, "0x%x\n", sdata->vif.active_links);
 721}
 722
 723static ssize_t ieee80211_if_parse_active_links(struct ieee80211_sub_if_data *sdata,
 724					       const char *buf, int buflen)
 725{
 726	u16 active_links;
 727
 728	if (kstrtou16(buf, 0, &active_links) || !active_links)
 729		return -EINVAL;
 730
 731	return ieee80211_set_active_links(&sdata->vif, active_links) ?: buflen;
 732}
 733IEEE80211_IF_FILE_RW(active_links);
 734
 735IEEE80211_IF_LINK_FILE(addr, conf->addr, MAC);
 736
 737#ifdef CONFIG_MAC80211_MESH
 738IEEE80211_IF_FILE(estab_plinks, u.mesh.estab_plinks, ATOMIC);
 739
 740/* Mesh stats attributes */
 741IEEE80211_IF_FILE(fwded_mcast, u.mesh.mshstats.fwded_mcast, DEC);
 742IEEE80211_IF_FILE(fwded_unicast, u.mesh.mshstats.fwded_unicast, DEC);
 743IEEE80211_IF_FILE(fwded_frames, u.mesh.mshstats.fwded_frames, DEC);
 744IEEE80211_IF_FILE(dropped_frames_ttl, u.mesh.mshstats.dropped_frames_ttl, DEC);
 745IEEE80211_IF_FILE(dropped_frames_no_route,
 746		  u.mesh.mshstats.dropped_frames_no_route, DEC);
 747
 748/* Mesh parameters */
 749IEEE80211_IF_FILE(dot11MeshMaxRetries,
 750		  u.mesh.mshcfg.dot11MeshMaxRetries, DEC);
 751IEEE80211_IF_FILE(dot11MeshRetryTimeout,
 752		  u.mesh.mshcfg.dot11MeshRetryTimeout, DEC);
 753IEEE80211_IF_FILE(dot11MeshConfirmTimeout,
 754		  u.mesh.mshcfg.dot11MeshConfirmTimeout, DEC);
 755IEEE80211_IF_FILE(dot11MeshHoldingTimeout,
 756		  u.mesh.mshcfg.dot11MeshHoldingTimeout, DEC);
 757IEEE80211_IF_FILE(dot11MeshTTL, u.mesh.mshcfg.dot11MeshTTL, DEC);
 758IEEE80211_IF_FILE(element_ttl, u.mesh.mshcfg.element_ttl, DEC);
 759IEEE80211_IF_FILE(auto_open_plinks, u.mesh.mshcfg.auto_open_plinks, DEC);
 760IEEE80211_IF_FILE(dot11MeshMaxPeerLinks,
 761		  u.mesh.mshcfg.dot11MeshMaxPeerLinks, DEC);
 762IEEE80211_IF_FILE(dot11MeshHWMPactivePathTimeout,
 763		  u.mesh.mshcfg.dot11MeshHWMPactivePathTimeout, DEC);
 764IEEE80211_IF_FILE(dot11MeshHWMPpreqMinInterval,
 765		  u.mesh.mshcfg.dot11MeshHWMPpreqMinInterval, DEC);
 766IEEE80211_IF_FILE(dot11MeshHWMPperrMinInterval,
 767		  u.mesh.mshcfg.dot11MeshHWMPperrMinInterval, DEC);
 768IEEE80211_IF_FILE(dot11MeshHWMPnetDiameterTraversalTime,
 769		  u.mesh.mshcfg.dot11MeshHWMPnetDiameterTraversalTime, DEC);
 770IEEE80211_IF_FILE(dot11MeshHWMPmaxPREQretries,
 771		  u.mesh.mshcfg.dot11MeshHWMPmaxPREQretries, DEC);
 772IEEE80211_IF_FILE(path_refresh_time,
 773		  u.mesh.mshcfg.path_refresh_time, DEC);
 774IEEE80211_IF_FILE(min_discovery_timeout,
 775		  u.mesh.mshcfg.min_discovery_timeout, DEC);
 776IEEE80211_IF_FILE(dot11MeshHWMPRootMode,
 777		  u.mesh.mshcfg.dot11MeshHWMPRootMode, DEC);
 778IEEE80211_IF_FILE(dot11MeshGateAnnouncementProtocol,
 779		  u.mesh.mshcfg.dot11MeshGateAnnouncementProtocol, DEC);
 780IEEE80211_IF_FILE(dot11MeshHWMPRannInterval,
 781		  u.mesh.mshcfg.dot11MeshHWMPRannInterval, DEC);
 782IEEE80211_IF_FILE(dot11MeshForwarding, u.mesh.mshcfg.dot11MeshForwarding, DEC);
 783IEEE80211_IF_FILE(rssi_threshold, u.mesh.mshcfg.rssi_threshold, DEC);
 784IEEE80211_IF_FILE(ht_opmode, u.mesh.mshcfg.ht_opmode, DEC);
 785IEEE80211_IF_FILE(dot11MeshHWMPactivePathToRootTimeout,
 786		  u.mesh.mshcfg.dot11MeshHWMPactivePathToRootTimeout, DEC);
 787IEEE80211_IF_FILE(dot11MeshHWMProotInterval,
 788		  u.mesh.mshcfg.dot11MeshHWMProotInterval, DEC);
 789IEEE80211_IF_FILE(dot11MeshHWMPconfirmationInterval,
 790		  u.mesh.mshcfg.dot11MeshHWMPconfirmationInterval, DEC);
 791IEEE80211_IF_FILE(power_mode, u.mesh.mshcfg.power_mode, DEC);
 792IEEE80211_IF_FILE(dot11MeshAwakeWindowDuration,
 793		  u.mesh.mshcfg.dot11MeshAwakeWindowDuration, DEC);
 794IEEE80211_IF_FILE(dot11MeshConnectedToMeshGate,
 795		  u.mesh.mshcfg.dot11MeshConnectedToMeshGate, DEC);
 796IEEE80211_IF_FILE(dot11MeshNolearn, u.mesh.mshcfg.dot11MeshNolearn, DEC);
 797IEEE80211_IF_FILE(dot11MeshConnectedToAuthServer,
 798		  u.mesh.mshcfg.dot11MeshConnectedToAuthServer, DEC);
 799#endif
 800
 801#define DEBUGFS_ADD_MODE(name, mode) \
 802	debugfs_create_file(#name, mode, sdata->vif.debugfs_dir, \
 803			    sdata, &name##_ops)
 804
 805#define DEBUGFS_ADD_X(_bits, _name, _mode) \
 806	debugfs_create_x##_bits(#_name, _mode, sdata->vif.debugfs_dir, \
 807				&sdata->vif._name)
 808
 809#define DEBUGFS_ADD_X8(_name, _mode) \
 810	DEBUGFS_ADD_X(8, _name, _mode)
 811
 812#define DEBUGFS_ADD_X16(_name, _mode) \
 813	DEBUGFS_ADD_X(16, _name, _mode)
 814
 815#define DEBUGFS_ADD_X32(_name, _mode) \
 816	DEBUGFS_ADD_X(32, _name, _mode)
 817
 818#define DEBUGFS_ADD(name) DEBUGFS_ADD_MODE(name, 0400)
 819
 820static void add_common_files(struct ieee80211_sub_if_data *sdata)
 821{
 822	DEBUGFS_ADD(rc_rateidx_mask_2ghz);
 823	DEBUGFS_ADD(rc_rateidx_mask_5ghz);
 824	DEBUGFS_ADD(rc_rateidx_mcs_mask_2ghz);
 825	DEBUGFS_ADD(rc_rateidx_mcs_mask_5ghz);
 826	DEBUGFS_ADD(rc_rateidx_vht_mcs_mask_2ghz);
 827	DEBUGFS_ADD(rc_rateidx_vht_mcs_mask_5ghz);
 828	DEBUGFS_ADD(hw_queues);
 829
 830	if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
 831	    sdata->vif.type != NL80211_IFTYPE_NAN)
 832		DEBUGFS_ADD(aqm);
 833}
 834
 835static void add_sta_files(struct ieee80211_sub_if_data *sdata)
 836{
 837	DEBUGFS_ADD(bssid);
 838	DEBUGFS_ADD(aid);
 839	DEBUGFS_ADD(beacon_timeout);
 840	DEBUGFS_ADD_MODE(tkip_mic_test, 0200);
 841	DEBUGFS_ADD_MODE(beacon_loss, 0200);
 842	DEBUGFS_ADD_MODE(uapsd_queues, 0600);
 843	DEBUGFS_ADD_MODE(uapsd_max_sp_len, 0600);
 844	DEBUGFS_ADD_MODE(tdls_wider_bw, 0600);
 845	DEBUGFS_ADD_MODE(valid_links, 0400);
 846	DEBUGFS_ADD_MODE(active_links, 0600);
 847	DEBUGFS_ADD_X16(dormant_links, 0400);
 848}
 849
 850static void add_ap_files(struct ieee80211_sub_if_data *sdata)
 851{
 852	DEBUGFS_ADD(num_mcast_sta);
 853	DEBUGFS_ADD(num_sta_ps);
 854	DEBUGFS_ADD(dtim_count);
 855	DEBUGFS_ADD(num_buffered_multicast);
 856	DEBUGFS_ADD_MODE(tkip_mic_test, 0200);
 857	DEBUGFS_ADD_MODE(multicast_to_unicast, 0600);
 858}
 859
 860static void add_vlan_files(struct ieee80211_sub_if_data *sdata)
 861{
 862	/* add num_mcast_sta_vlan using name num_mcast_sta */
 863	debugfs_create_file("num_mcast_sta", 0400, sdata->vif.debugfs_dir,
 864			    sdata, &num_mcast_sta_vlan_ops);
 865}
 866
 867static void add_ibss_files(struct ieee80211_sub_if_data *sdata)
 868{
 869	DEBUGFS_ADD_MODE(tsf, 0600);
 870}
 871
 872#ifdef CONFIG_MAC80211_MESH
 873
 874static void add_mesh_files(struct ieee80211_sub_if_data *sdata)
 875{
 876	DEBUGFS_ADD_MODE(tsf, 0600);
 877	DEBUGFS_ADD_MODE(estab_plinks, 0400);
 878}
 879
 880static void add_mesh_stats(struct ieee80211_sub_if_data *sdata)
 881{
 882	struct dentry *dir = debugfs_create_dir("mesh_stats",
 883						sdata->vif.debugfs_dir);
 884#define MESHSTATS_ADD(name)\
 885	debugfs_create_file(#name, 0400, dir, sdata, &name##_ops)
 886
 887	MESHSTATS_ADD(fwded_mcast);
 888	MESHSTATS_ADD(fwded_unicast);
 889	MESHSTATS_ADD(fwded_frames);
 890	MESHSTATS_ADD(dropped_frames_ttl);
 891	MESHSTATS_ADD(dropped_frames_no_route);
 892#undef MESHSTATS_ADD
 893}
 894
 895static void add_mesh_config(struct ieee80211_sub_if_data *sdata)
 896{
 897	struct dentry *dir = debugfs_create_dir("mesh_config",
 898						sdata->vif.debugfs_dir);
 899
 900#define MESHPARAMS_ADD(name) \
 901	debugfs_create_file(#name, 0600, dir, sdata, &name##_ops)
 902
 903	MESHPARAMS_ADD(dot11MeshMaxRetries);
 904	MESHPARAMS_ADD(dot11MeshRetryTimeout);
 905	MESHPARAMS_ADD(dot11MeshConfirmTimeout);
 906	MESHPARAMS_ADD(dot11MeshHoldingTimeout);
 907	MESHPARAMS_ADD(dot11MeshTTL);
 908	MESHPARAMS_ADD(element_ttl);
 909	MESHPARAMS_ADD(auto_open_plinks);
 910	MESHPARAMS_ADD(dot11MeshMaxPeerLinks);
 911	MESHPARAMS_ADD(dot11MeshHWMPactivePathTimeout);
 912	MESHPARAMS_ADD(dot11MeshHWMPpreqMinInterval);
 913	MESHPARAMS_ADD(dot11MeshHWMPperrMinInterval);
 914	MESHPARAMS_ADD(dot11MeshHWMPnetDiameterTraversalTime);
 915	MESHPARAMS_ADD(dot11MeshHWMPmaxPREQretries);
 916	MESHPARAMS_ADD(path_refresh_time);
 917	MESHPARAMS_ADD(min_discovery_timeout);
 918	MESHPARAMS_ADD(dot11MeshHWMPRootMode);
 919	MESHPARAMS_ADD(dot11MeshHWMPRannInterval);
 920	MESHPARAMS_ADD(dot11MeshForwarding);
 921	MESHPARAMS_ADD(dot11MeshGateAnnouncementProtocol);
 922	MESHPARAMS_ADD(rssi_threshold);
 923	MESHPARAMS_ADD(ht_opmode);
 924	MESHPARAMS_ADD(dot11MeshHWMPactivePathToRootTimeout);
 925	MESHPARAMS_ADD(dot11MeshHWMProotInterval);
 926	MESHPARAMS_ADD(dot11MeshHWMPconfirmationInterval);
 927	MESHPARAMS_ADD(power_mode);
 928	MESHPARAMS_ADD(dot11MeshAwakeWindowDuration);
 929	MESHPARAMS_ADD(dot11MeshConnectedToMeshGate);
 930	MESHPARAMS_ADD(dot11MeshNolearn);
 931	MESHPARAMS_ADD(dot11MeshConnectedToAuthServer);
 932#undef MESHPARAMS_ADD
 933}
 934#endif
 935
 936static void add_files(struct ieee80211_sub_if_data *sdata)
 937{
 938	if (!sdata->vif.debugfs_dir)
 939		return;
 940
 941	DEBUGFS_ADD(flags);
 942	DEBUGFS_ADD(state);
 943
 944	if (sdata->vif.type != NL80211_IFTYPE_MONITOR)
 945		add_common_files(sdata);
 946
 947	switch (sdata->vif.type) {
 948	case NL80211_IFTYPE_MESH_POINT:
 949#ifdef CONFIG_MAC80211_MESH
 950		add_mesh_files(sdata);
 951		add_mesh_stats(sdata);
 952		add_mesh_config(sdata);
 953#endif
 954		break;
 955	case NL80211_IFTYPE_STATION:
 956		add_sta_files(sdata);
 957		break;
 958	case NL80211_IFTYPE_ADHOC:
 959		add_ibss_files(sdata);
 960		break;
 961	case NL80211_IFTYPE_AP:
 962		add_ap_files(sdata);
 963		break;
 964	case NL80211_IFTYPE_AP_VLAN:
 965		add_vlan_files(sdata);
 966		break;
 967	default:
 968		break;
 969	}
 970}
 971
 972#undef DEBUGFS_ADD_MODE
 973#undef DEBUGFS_ADD
 974
 975#define DEBUGFS_ADD_MODE(dentry, name, mode) \
 976	debugfs_create_file(#name, mode, dentry, \
 977			    link, &link_##name##_ops)
 978
 979#define DEBUGFS_ADD(dentry, name) DEBUGFS_ADD_MODE(dentry, name, 0400)
 980
 981static void add_link_files(struct ieee80211_link_data *link,
 982			   struct dentry *dentry)
 983{
 984	DEBUGFS_ADD(dentry, txpower);
 985	DEBUGFS_ADD(dentry, user_power_level);
 986	DEBUGFS_ADD(dentry, ap_power_level);
 987
 988	switch (link->sdata->vif.type) {
 989	case NL80211_IFTYPE_STATION:
 990		DEBUGFS_ADD_MODE(dentry, smps, 0600);
 991		break;
 992	default:
 993		break;
 994	}
 995}
 996
 997static void ieee80211_debugfs_add_netdev(struct ieee80211_sub_if_data *sdata,
 998					 bool mld_vif)
 999{
1000	char buf[10+IFNAMSIZ];
1001
1002	sprintf(buf, "netdev:%s", sdata->name);
1003	sdata->vif.debugfs_dir = debugfs_create_dir(buf,
1004		sdata->local->hw.wiphy->debugfsdir);
1005	/* deflink also has this */
1006	sdata->deflink.debugfs_dir = sdata->vif.debugfs_dir;
1007	sdata->debugfs.subdir_stations = debugfs_create_dir("stations",
1008							sdata->vif.debugfs_dir);
1009	add_files(sdata);
1010	if (!mld_vif)
1011		add_link_files(&sdata->deflink, sdata->vif.debugfs_dir);
1012}
1013
1014void ieee80211_debugfs_remove_netdev(struct ieee80211_sub_if_data *sdata)
1015{
1016	if (!sdata->vif.debugfs_dir)
1017		return;
1018
1019	debugfs_remove_recursive(sdata->vif.debugfs_dir);
1020	sdata->vif.debugfs_dir = NULL;
1021	sdata->debugfs.subdir_stations = NULL;
1022}
1023
1024void ieee80211_debugfs_rename_netdev(struct ieee80211_sub_if_data *sdata)
1025{
1026	debugfs_change_name(sdata->vif.debugfs_dir, "netdev:%s", sdata->name);
1027}
1028
1029void ieee80211_debugfs_recreate_netdev(struct ieee80211_sub_if_data *sdata,
1030				       bool mld_vif)
1031{
1032	ieee80211_debugfs_remove_netdev(sdata);
1033	ieee80211_debugfs_add_netdev(sdata, mld_vif);
1034
1035	if (sdata->flags & IEEE80211_SDATA_IN_DRIVER) {
1036		drv_vif_add_debugfs(sdata->local, sdata);
1037		if (!mld_vif)
1038			ieee80211_link_debugfs_drv_add(&sdata->deflink);
1039	}
1040}
1041
1042void ieee80211_link_debugfs_add(struct ieee80211_link_data *link)
1043{
1044	char link_dir_name[10];
1045
1046	if (WARN_ON(!link->sdata->vif.debugfs_dir || link->debugfs_dir))
1047		return;
1048
1049	/* For now, this should not be called for non-MLO capable drivers */
1050	if (WARN_ON(!(link->sdata->local->hw.wiphy->flags & WIPHY_FLAG_SUPPORTS_MLO)))
1051		return;
1052
1053	snprintf(link_dir_name, sizeof(link_dir_name),
1054		 "link-%d", link->link_id);
1055
1056	link->debugfs_dir =
1057		debugfs_create_dir(link_dir_name,
1058				   link->sdata->vif.debugfs_dir);
1059
1060	DEBUGFS_ADD(link->debugfs_dir, addr);
1061	add_link_files(link, link->debugfs_dir);
1062}
1063
1064void ieee80211_link_debugfs_remove(struct ieee80211_link_data *link)
1065{
1066	if (!link->sdata->vif.debugfs_dir || !link->debugfs_dir) {
1067		link->debugfs_dir = NULL;
1068		return;
1069	}
1070
1071	if (link->debugfs_dir == link->sdata->vif.debugfs_dir) {
1072		WARN_ON(link != &link->sdata->deflink);
1073		link->debugfs_dir = NULL;
1074		return;
1075	}
1076
1077	debugfs_remove_recursive(link->debugfs_dir);
1078	link->debugfs_dir = NULL;
1079}
1080
1081void ieee80211_link_debugfs_drv_add(struct ieee80211_link_data *link)
1082{
1083	if (link->sdata->vif.type == NL80211_IFTYPE_MONITOR ||
1084	    WARN_ON(!link->debugfs_dir))
1085		return;
1086
1087	drv_link_add_debugfs(link->sdata->local, link->sdata,
1088			     link->conf, link->debugfs_dir);
1089}
1090
1091void ieee80211_link_debugfs_drv_remove(struct ieee80211_link_data *link)
1092{
1093	if (!link || !link->debugfs_dir)
1094		return;
1095
1096	if (WARN_ON(link->debugfs_dir == link->sdata->vif.debugfs_dir))
1097		return;
1098
1099	/* Recreate the directory excluding the driver data */
1100	debugfs_remove_recursive(link->debugfs_dir);
1101	link->debugfs_dir = NULL;
1102
1103	ieee80211_link_debugfs_add(link);
1104}