Merge tag 'livepatching-for-5.20' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6-microblaze.git] / net / mac80211 / 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-2022 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
25 static ssize_t ieee80211_if_read(
26         struct ieee80211_sub_if_data *sdata,
27         char __user *userbuf,
28         size_t count, loff_t *ppos,
29         ssize_t (*format)(const struct ieee80211_sub_if_data *, char *, int))
30 {
31         char buf[200];
32         ssize_t ret = -EINVAL;
33
34         read_lock(&dev_base_lock);
35         ret = (*format)(sdata, buf, sizeof(buf));
36         read_unlock(&dev_base_lock);
37
38         if (ret >= 0)
39                 ret = simple_read_from_buffer(userbuf, count, ppos, buf, ret);
40
41         return ret;
42 }
43
44 static ssize_t ieee80211_if_write(
45         struct ieee80211_sub_if_data *sdata,
46         const char __user *userbuf,
47         size_t count, loff_t *ppos,
48         ssize_t (*write)(struct ieee80211_sub_if_data *, const char *, int))
49 {
50         char buf[64];
51         ssize_t ret;
52
53         if (count >= sizeof(buf))
54                 return -E2BIG;
55
56         if (copy_from_user(buf, userbuf, count))
57                 return -EFAULT;
58         buf[count] = '\0';
59
60         rtnl_lock();
61         ret = (*write)(sdata, buf, count);
62         rtnl_unlock();
63
64         return ret;
65 }
66
67 #define IEEE80211_IF_FMT(name, field, format_string)                    \
68 static ssize_t ieee80211_if_fmt_##name(                                 \
69         const struct ieee80211_sub_if_data *sdata, char *buf,           \
70         int buflen)                                                     \
71 {                                                                       \
72         return scnprintf(buf, buflen, format_string, sdata->field);     \
73 }
74 #define IEEE80211_IF_FMT_DEC(name, field)                               \
75                 IEEE80211_IF_FMT(name, field, "%d\n")
76 #define IEEE80211_IF_FMT_HEX(name, field)                               \
77                 IEEE80211_IF_FMT(name, field, "%#x\n")
78 #define IEEE80211_IF_FMT_LHEX(name, field)                              \
79                 IEEE80211_IF_FMT(name, field, "%#lx\n")
80
81 #define IEEE80211_IF_FMT_HEXARRAY(name, field)                          \
82 static ssize_t ieee80211_if_fmt_##name(                                 \
83         const struct ieee80211_sub_if_data *sdata,                      \
84         char *buf, int buflen)                                          \
85 {                                                                       \
86         char *p = buf;                                                  \
87         int i;                                                          \
88         for (i = 0; i < sizeof(sdata->field); i++) {                    \
89                 p += scnprintf(p, buflen + buf - p, "%.2x ",            \
90                                  sdata->field[i]);                      \
91         }                                                               \
92         p += scnprintf(p, buflen + buf - p, "\n");                      \
93         return p - buf;                                                 \
94 }
95
96 #define IEEE80211_IF_FMT_ATOMIC(name, field)                            \
97 static ssize_t ieee80211_if_fmt_##name(                                 \
98         const struct ieee80211_sub_if_data *sdata,                      \
99         char *buf, int buflen)                                          \
100 {                                                                       \
101         return scnprintf(buf, buflen, "%d\n", atomic_read(&sdata->field));\
102 }
103
104 #define IEEE80211_IF_FMT_MAC(name, field)                               \
105 static ssize_t ieee80211_if_fmt_##name(                                 \
106         const struct ieee80211_sub_if_data *sdata, char *buf,           \
107         int buflen)                                                     \
108 {                                                                       \
109         return scnprintf(buf, buflen, "%pM\n", sdata->field);           \
110 }
111
112 #define IEEE80211_IF_FMT_JIFFIES_TO_MS(name, field)                     \
113 static ssize_t ieee80211_if_fmt_##name(                                 \
114         const struct ieee80211_sub_if_data *sdata,                      \
115         char *buf, int buflen)                                          \
116 {                                                                       \
117         return scnprintf(buf, buflen, "%d\n",                           \
118                          jiffies_to_msecs(sdata->field));               \
119 }
120
121 #define _IEEE80211_IF_FILE_OPS(name, _read, _write)                     \
122 static const struct file_operations name##_ops = {                      \
123         .read = (_read),                                                \
124         .write = (_write),                                              \
125         .open = simple_open,                                            \
126         .llseek = generic_file_llseek,                                  \
127 }
128
129 #define _IEEE80211_IF_FILE_R_FN(name)                                   \
130 static ssize_t ieee80211_if_read_##name(struct file *file,              \
131                                         char __user *userbuf,           \
132                                         size_t count, loff_t *ppos)     \
133 {                                                                       \
134         return ieee80211_if_read(file->private_data,                    \
135                                  userbuf, count, ppos,                  \
136                                  ieee80211_if_fmt_##name);              \
137 }
138
139 #define _IEEE80211_IF_FILE_W_FN(name)                                   \
140 static ssize_t ieee80211_if_write_##name(struct file *file,             \
141                                          const char __user *userbuf,    \
142                                          size_t count, loff_t *ppos)    \
143 {                                                                       \
144         return ieee80211_if_write(file->private_data, userbuf, count,   \
145                                   ppos, ieee80211_if_parse_##name);     \
146 }
147
148 #define IEEE80211_IF_FILE_R(name)                                       \
149         _IEEE80211_IF_FILE_R_FN(name)                                   \
150         _IEEE80211_IF_FILE_OPS(name, ieee80211_if_read_##name, NULL)
151
152 #define IEEE80211_IF_FILE_W(name)                                       \
153         _IEEE80211_IF_FILE_W_FN(name)                                   \
154         _IEEE80211_IF_FILE_OPS(name, NULL, ieee80211_if_write_##name)
155
156 #define IEEE80211_IF_FILE_RW(name)                                      \
157         _IEEE80211_IF_FILE_R_FN(name)                                   \
158         _IEEE80211_IF_FILE_W_FN(name)                                   \
159         _IEEE80211_IF_FILE_OPS(name, ieee80211_if_read_##name,          \
160                                ieee80211_if_write_##name)
161
162 #define IEEE80211_IF_FILE(name, field, format)                          \
163         IEEE80211_IF_FMT_##format(name, field)                          \
164         IEEE80211_IF_FILE_R(name)
165
166 /* common attributes */
167 IEEE80211_IF_FILE(rc_rateidx_mask_2ghz, rc_rateidx_mask[NL80211_BAND_2GHZ],
168                   HEX);
169 IEEE80211_IF_FILE(rc_rateidx_mask_5ghz, rc_rateidx_mask[NL80211_BAND_5GHZ],
170                   HEX);
171 IEEE80211_IF_FILE(rc_rateidx_mcs_mask_2ghz,
172                   rc_rateidx_mcs_mask[NL80211_BAND_2GHZ], HEXARRAY);
173 IEEE80211_IF_FILE(rc_rateidx_mcs_mask_5ghz,
174                   rc_rateidx_mcs_mask[NL80211_BAND_5GHZ], HEXARRAY);
175
176 static ssize_t ieee80211_if_fmt_rc_rateidx_vht_mcs_mask_2ghz(
177                                 const struct ieee80211_sub_if_data *sdata,
178                                 char *buf, int buflen)
179 {
180         int i, len = 0;
181         const u16 *mask = sdata->rc_rateidx_vht_mcs_mask[NL80211_BAND_2GHZ];
182
183         for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
184                 len += scnprintf(buf + len, buflen - len, "%04x ", mask[i]);
185         len += scnprintf(buf + len, buflen - len, "\n");
186
187         return len;
188 }
189
190 IEEE80211_IF_FILE_R(rc_rateidx_vht_mcs_mask_2ghz);
191
192 static ssize_t ieee80211_if_fmt_rc_rateidx_vht_mcs_mask_5ghz(
193                                 const struct ieee80211_sub_if_data *sdata,
194                                 char *buf, int buflen)
195 {
196         int i, len = 0;
197         const u16 *mask = sdata->rc_rateidx_vht_mcs_mask[NL80211_BAND_5GHZ];
198
199         for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
200                 len += scnprintf(buf + len, buflen - len, "%04x ", mask[i]);
201         len += scnprintf(buf + len, buflen - len, "\n");
202
203         return len;
204 }
205
206 IEEE80211_IF_FILE_R(rc_rateidx_vht_mcs_mask_5ghz);
207
208 IEEE80211_IF_FILE(flags, flags, HEX);
209 IEEE80211_IF_FILE(state, state, LHEX);
210 IEEE80211_IF_FILE(txpower, vif.bss_conf.txpower, DEC);
211 IEEE80211_IF_FILE(ap_power_level, deflink.ap_power_level, DEC);
212 IEEE80211_IF_FILE(user_power_level, deflink.user_power_level, DEC);
213
214 static ssize_t
215 ieee80211_if_fmt_hw_queues(const struct ieee80211_sub_if_data *sdata,
216                            char *buf, int buflen)
217 {
218         int len;
219
220         len = scnprintf(buf, buflen, "AC queues: VO:%d VI:%d BE:%d BK:%d\n",
221                         sdata->vif.hw_queue[IEEE80211_AC_VO],
222                         sdata->vif.hw_queue[IEEE80211_AC_VI],
223                         sdata->vif.hw_queue[IEEE80211_AC_BE],
224                         sdata->vif.hw_queue[IEEE80211_AC_BK]);
225
226         if (sdata->vif.type == NL80211_IFTYPE_AP)
227                 len += scnprintf(buf + len, buflen - len, "cab queue: %d\n",
228                                  sdata->vif.cab_queue);
229
230         return len;
231 }
232 IEEE80211_IF_FILE_R(hw_queues);
233
234 /* STA attributes */
235 IEEE80211_IF_FILE(bssid, deflink.u.mgd.bssid, MAC);
236 IEEE80211_IF_FILE(aid, vif.cfg.aid, DEC);
237 IEEE80211_IF_FILE(beacon_timeout, u.mgd.beacon_timeout, JIFFIES_TO_MS);
238
239 static int ieee80211_set_smps(struct ieee80211_sub_if_data *sdata,
240                               enum ieee80211_smps_mode smps_mode)
241 {
242         struct ieee80211_local *local = sdata->local;
243         int err;
244
245         if (!(local->hw.wiphy->features & NL80211_FEATURE_STATIC_SMPS) &&
246             smps_mode == IEEE80211_SMPS_STATIC)
247                 return -EINVAL;
248
249         /* auto should be dynamic if in PS mode */
250         if (!(local->hw.wiphy->features & NL80211_FEATURE_DYNAMIC_SMPS) &&
251             (smps_mode == IEEE80211_SMPS_DYNAMIC ||
252              smps_mode == IEEE80211_SMPS_AUTOMATIC))
253                 return -EINVAL;
254
255         if (sdata->vif.type != NL80211_IFTYPE_STATION)
256                 return -EOPNOTSUPP;
257
258         sdata_lock(sdata);
259         err = __ieee80211_request_smps_mgd(sdata, &sdata->deflink, smps_mode);
260         sdata_unlock(sdata);
261
262         return err;
263 }
264
265 static const char *smps_modes[IEEE80211_SMPS_NUM_MODES] = {
266         [IEEE80211_SMPS_AUTOMATIC] = "auto",
267         [IEEE80211_SMPS_OFF] = "off",
268         [IEEE80211_SMPS_STATIC] = "static",
269         [IEEE80211_SMPS_DYNAMIC] = "dynamic",
270 };
271
272 static ssize_t ieee80211_if_fmt_smps(const struct ieee80211_sub_if_data *sdata,
273                                      char *buf, int buflen)
274 {
275         if (sdata->vif.type == NL80211_IFTYPE_STATION)
276                 return snprintf(buf, buflen, "request: %s\nused: %s\n",
277                                 smps_modes[sdata->deflink.u.mgd.req_smps],
278                                 smps_modes[sdata->deflink.smps_mode]);
279         return -EINVAL;
280 }
281
282 static ssize_t ieee80211_if_parse_smps(struct ieee80211_sub_if_data *sdata,
283                                        const char *buf, int buflen)
284 {
285         enum ieee80211_smps_mode mode;
286
287         for (mode = 0; mode < IEEE80211_SMPS_NUM_MODES; mode++) {
288                 if (strncmp(buf, smps_modes[mode], buflen) == 0) {
289                         int err = ieee80211_set_smps(sdata, mode);
290                         if (!err)
291                                 return buflen;
292                         return err;
293                 }
294         }
295
296         return -EINVAL;
297 }
298 IEEE80211_IF_FILE_RW(smps);
299
300 static ssize_t ieee80211_if_parse_tkip_mic_test(
301         struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
302 {
303         struct ieee80211_local *local = sdata->local;
304         u8 addr[ETH_ALEN];
305         struct sk_buff *skb;
306         struct ieee80211_hdr *hdr;
307         __le16 fc;
308
309         if (!mac_pton(buf, addr))
310                 return -EINVAL;
311
312         if (!ieee80211_sdata_running(sdata))
313                 return -ENOTCONN;
314
315         skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24 + 100);
316         if (!skb)
317                 return -ENOMEM;
318         skb_reserve(skb, local->hw.extra_tx_headroom);
319
320         hdr = skb_put_zero(skb, 24);
321         fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA);
322
323         switch (sdata->vif.type) {
324         case NL80211_IFTYPE_AP:
325                 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
326                 /* DA BSSID SA */
327                 memcpy(hdr->addr1, addr, ETH_ALEN);
328                 memcpy(hdr->addr2, sdata->vif.addr, ETH_ALEN);
329                 memcpy(hdr->addr3, sdata->vif.addr, ETH_ALEN);
330                 break;
331         case NL80211_IFTYPE_STATION:
332                 fc |= cpu_to_le16(IEEE80211_FCTL_TODS);
333                 /* BSSID SA DA */
334                 sdata_lock(sdata);
335                 if (!sdata->u.mgd.associated) {
336                         sdata_unlock(sdata);
337                         dev_kfree_skb(skb);
338                         return -ENOTCONN;
339                 }
340                 memcpy(hdr->addr1, sdata->deflink.u.mgd.bssid, ETH_ALEN);
341                 memcpy(hdr->addr2, sdata->vif.addr, ETH_ALEN);
342                 memcpy(hdr->addr3, addr, ETH_ALEN);
343                 sdata_unlock(sdata);
344                 break;
345         default:
346                 dev_kfree_skb(skb);
347                 return -EOPNOTSUPP;
348         }
349         hdr->frame_control = fc;
350
351         /*
352          * Add some length to the test frame to make it look bit more valid.
353          * The exact contents does not matter since the recipient is required
354          * to drop this because of the Michael MIC failure.
355          */
356         skb_put_zero(skb, 50);
357
358         IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_TKIP_MIC_FAILURE;
359
360         ieee80211_tx_skb(sdata, skb);
361
362         return buflen;
363 }
364 IEEE80211_IF_FILE_W(tkip_mic_test);
365
366 static ssize_t ieee80211_if_parse_beacon_loss(
367         struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
368 {
369         if (!ieee80211_sdata_running(sdata) || !sdata->vif.cfg.assoc)
370                 return -ENOTCONN;
371
372         ieee80211_beacon_loss(&sdata->vif);
373
374         return buflen;
375 }
376 IEEE80211_IF_FILE_W(beacon_loss);
377
378 static ssize_t ieee80211_if_fmt_uapsd_queues(
379         const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
380 {
381         const struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
382
383         return snprintf(buf, buflen, "0x%x\n", ifmgd->uapsd_queues);
384 }
385
386 static ssize_t ieee80211_if_parse_uapsd_queues(
387         struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
388 {
389         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
390         u8 val;
391         int ret;
392
393         ret = kstrtou8(buf, 0, &val);
394         if (ret)
395                 return ret;
396
397         if (val & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
398                 return -ERANGE;
399
400         ifmgd->uapsd_queues = val;
401
402         return buflen;
403 }
404 IEEE80211_IF_FILE_RW(uapsd_queues);
405
406 static ssize_t ieee80211_if_fmt_uapsd_max_sp_len(
407         const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
408 {
409         const struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
410
411         return snprintf(buf, buflen, "0x%x\n", ifmgd->uapsd_max_sp_len);
412 }
413
414 static ssize_t ieee80211_if_parse_uapsd_max_sp_len(
415         struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
416 {
417         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
418         unsigned long val;
419         int ret;
420
421         ret = kstrtoul(buf, 0, &val);
422         if (ret)
423                 return -EINVAL;
424
425         if (val & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
426                 return -ERANGE;
427
428         ifmgd->uapsd_max_sp_len = val;
429
430         return buflen;
431 }
432 IEEE80211_IF_FILE_RW(uapsd_max_sp_len);
433
434 static ssize_t ieee80211_if_fmt_tdls_wider_bw(
435         const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
436 {
437         const struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
438         bool tdls_wider_bw;
439
440         tdls_wider_bw = ieee80211_hw_check(&sdata->local->hw, TDLS_WIDER_BW) &&
441                         !ifmgd->tdls_wider_bw_prohibited;
442
443         return snprintf(buf, buflen, "%d\n", tdls_wider_bw);
444 }
445
446 static ssize_t ieee80211_if_parse_tdls_wider_bw(
447         struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
448 {
449         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
450         u8 val;
451         int ret;
452
453         ret = kstrtou8(buf, 0, &val);
454         if (ret)
455                 return ret;
456
457         ifmgd->tdls_wider_bw_prohibited = !val;
458         return buflen;
459 }
460 IEEE80211_IF_FILE_RW(tdls_wider_bw);
461
462 /* AP attributes */
463 IEEE80211_IF_FILE(num_mcast_sta, u.ap.num_mcast_sta, ATOMIC);
464 IEEE80211_IF_FILE(num_sta_ps, u.ap.ps.num_sta_ps, ATOMIC);
465 IEEE80211_IF_FILE(dtim_count, u.ap.ps.dtim_count, DEC);
466 IEEE80211_IF_FILE(num_mcast_sta_vlan, u.vlan.num_mcast_sta, ATOMIC);
467
468 static ssize_t ieee80211_if_fmt_num_buffered_multicast(
469         const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
470 {
471         return scnprintf(buf, buflen, "%u\n",
472                          skb_queue_len(&sdata->u.ap.ps.bc_buf));
473 }
474 IEEE80211_IF_FILE_R(num_buffered_multicast);
475
476 static ssize_t ieee80211_if_fmt_aqm(
477         const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
478 {
479         struct ieee80211_local *local = sdata->local;
480         struct txq_info *txqi;
481         int len;
482
483         if (!sdata->vif.txq)
484                 return 0;
485
486         txqi = to_txq_info(sdata->vif.txq);
487
488         spin_lock_bh(&local->fq.lock);
489         rcu_read_lock();
490
491         len = scnprintf(buf,
492                         buflen,
493                         "ac backlog-bytes backlog-packets new-flows drops marks overlimit collisions tx-bytes tx-packets\n"
494                         "%u %u %u %u %u %u %u %u %u %u\n",
495                         txqi->txq.ac,
496                         txqi->tin.backlog_bytes,
497                         txqi->tin.backlog_packets,
498                         txqi->tin.flows,
499                         txqi->cstats.drop_count,
500                         txqi->cstats.ecn_mark,
501                         txqi->tin.overlimit,
502                         txqi->tin.collisions,
503                         txqi->tin.tx_bytes,
504                         txqi->tin.tx_packets);
505
506         rcu_read_unlock();
507         spin_unlock_bh(&local->fq.lock);
508
509         return len;
510 }
511 IEEE80211_IF_FILE_R(aqm);
512
513 IEEE80211_IF_FILE(multicast_to_unicast, u.ap.multicast_to_unicast, HEX);
514
515 /* IBSS attributes */
516 static ssize_t ieee80211_if_fmt_tsf(
517         const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
518 {
519         struct ieee80211_local *local = sdata->local;
520         u64 tsf;
521
522         tsf = drv_get_tsf(local, (struct ieee80211_sub_if_data *)sdata);
523
524         return scnprintf(buf, buflen, "0x%016llx\n", (unsigned long long) tsf);
525 }
526
527 static ssize_t ieee80211_if_parse_tsf(
528         struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
529 {
530         struct ieee80211_local *local = sdata->local;
531         unsigned long long tsf;
532         int ret;
533         int tsf_is_delta = 0;
534
535         if (strncmp(buf, "reset", 5) == 0) {
536                 if (local->ops->reset_tsf) {
537                         drv_reset_tsf(local, sdata);
538                         wiphy_info(local->hw.wiphy, "debugfs reset TSF\n");
539                 }
540         } else {
541                 if (buflen > 10 && buf[1] == '=') {
542                         if (buf[0] == '+')
543                                 tsf_is_delta = 1;
544                         else if (buf[0] == '-')
545                                 tsf_is_delta = -1;
546                         else
547                                 return -EINVAL;
548                         buf += 2;
549                 }
550                 ret = kstrtoull(buf, 10, &tsf);
551                 if (ret < 0)
552                         return ret;
553                 if (tsf_is_delta && local->ops->offset_tsf) {
554                         drv_offset_tsf(local, sdata, tsf_is_delta * tsf);
555                         wiphy_info(local->hw.wiphy,
556                                    "debugfs offset TSF by %018lld\n",
557                                    tsf_is_delta * tsf);
558                 } else if (local->ops->set_tsf) {
559                         if (tsf_is_delta)
560                                 tsf = drv_get_tsf(local, sdata) +
561                                       tsf_is_delta * tsf;
562                         drv_set_tsf(local, sdata, tsf);
563                         wiphy_info(local->hw.wiphy,
564                                    "debugfs set TSF to %#018llx\n", tsf);
565                 }
566         }
567
568         ieee80211_recalc_dtim(local, sdata);
569         return buflen;
570 }
571 IEEE80211_IF_FILE_RW(tsf);
572
573
574 #ifdef CONFIG_MAC80211_MESH
575 IEEE80211_IF_FILE(estab_plinks, u.mesh.estab_plinks, ATOMIC);
576
577 /* Mesh stats attributes */
578 IEEE80211_IF_FILE(fwded_mcast, u.mesh.mshstats.fwded_mcast, DEC);
579 IEEE80211_IF_FILE(fwded_unicast, u.mesh.mshstats.fwded_unicast, DEC);
580 IEEE80211_IF_FILE(fwded_frames, u.mesh.mshstats.fwded_frames, DEC);
581 IEEE80211_IF_FILE(dropped_frames_ttl, u.mesh.mshstats.dropped_frames_ttl, DEC);
582 IEEE80211_IF_FILE(dropped_frames_congestion,
583                   u.mesh.mshstats.dropped_frames_congestion, DEC);
584 IEEE80211_IF_FILE(dropped_frames_no_route,
585                   u.mesh.mshstats.dropped_frames_no_route, DEC);
586
587 /* Mesh parameters */
588 IEEE80211_IF_FILE(dot11MeshMaxRetries,
589                   u.mesh.mshcfg.dot11MeshMaxRetries, DEC);
590 IEEE80211_IF_FILE(dot11MeshRetryTimeout,
591                   u.mesh.mshcfg.dot11MeshRetryTimeout, DEC);
592 IEEE80211_IF_FILE(dot11MeshConfirmTimeout,
593                   u.mesh.mshcfg.dot11MeshConfirmTimeout, DEC);
594 IEEE80211_IF_FILE(dot11MeshHoldingTimeout,
595                   u.mesh.mshcfg.dot11MeshHoldingTimeout, DEC);
596 IEEE80211_IF_FILE(dot11MeshTTL, u.mesh.mshcfg.dot11MeshTTL, DEC);
597 IEEE80211_IF_FILE(element_ttl, u.mesh.mshcfg.element_ttl, DEC);
598 IEEE80211_IF_FILE(auto_open_plinks, u.mesh.mshcfg.auto_open_plinks, DEC);
599 IEEE80211_IF_FILE(dot11MeshMaxPeerLinks,
600                   u.mesh.mshcfg.dot11MeshMaxPeerLinks, DEC);
601 IEEE80211_IF_FILE(dot11MeshHWMPactivePathTimeout,
602                   u.mesh.mshcfg.dot11MeshHWMPactivePathTimeout, DEC);
603 IEEE80211_IF_FILE(dot11MeshHWMPpreqMinInterval,
604                   u.mesh.mshcfg.dot11MeshHWMPpreqMinInterval, DEC);
605 IEEE80211_IF_FILE(dot11MeshHWMPperrMinInterval,
606                   u.mesh.mshcfg.dot11MeshHWMPperrMinInterval, DEC);
607 IEEE80211_IF_FILE(dot11MeshHWMPnetDiameterTraversalTime,
608                   u.mesh.mshcfg.dot11MeshHWMPnetDiameterTraversalTime, DEC);
609 IEEE80211_IF_FILE(dot11MeshHWMPmaxPREQretries,
610                   u.mesh.mshcfg.dot11MeshHWMPmaxPREQretries, DEC);
611 IEEE80211_IF_FILE(path_refresh_time,
612                   u.mesh.mshcfg.path_refresh_time, DEC);
613 IEEE80211_IF_FILE(min_discovery_timeout,
614                   u.mesh.mshcfg.min_discovery_timeout, DEC);
615 IEEE80211_IF_FILE(dot11MeshHWMPRootMode,
616                   u.mesh.mshcfg.dot11MeshHWMPRootMode, DEC);
617 IEEE80211_IF_FILE(dot11MeshGateAnnouncementProtocol,
618                   u.mesh.mshcfg.dot11MeshGateAnnouncementProtocol, DEC);
619 IEEE80211_IF_FILE(dot11MeshHWMPRannInterval,
620                   u.mesh.mshcfg.dot11MeshHWMPRannInterval, DEC);
621 IEEE80211_IF_FILE(dot11MeshForwarding, u.mesh.mshcfg.dot11MeshForwarding, DEC);
622 IEEE80211_IF_FILE(rssi_threshold, u.mesh.mshcfg.rssi_threshold, DEC);
623 IEEE80211_IF_FILE(ht_opmode, u.mesh.mshcfg.ht_opmode, DEC);
624 IEEE80211_IF_FILE(dot11MeshHWMPactivePathToRootTimeout,
625                   u.mesh.mshcfg.dot11MeshHWMPactivePathToRootTimeout, DEC);
626 IEEE80211_IF_FILE(dot11MeshHWMProotInterval,
627                   u.mesh.mshcfg.dot11MeshHWMProotInterval, DEC);
628 IEEE80211_IF_FILE(dot11MeshHWMPconfirmationInterval,
629                   u.mesh.mshcfg.dot11MeshHWMPconfirmationInterval, DEC);
630 IEEE80211_IF_FILE(power_mode, u.mesh.mshcfg.power_mode, DEC);
631 IEEE80211_IF_FILE(dot11MeshAwakeWindowDuration,
632                   u.mesh.mshcfg.dot11MeshAwakeWindowDuration, DEC);
633 IEEE80211_IF_FILE(dot11MeshConnectedToMeshGate,
634                   u.mesh.mshcfg.dot11MeshConnectedToMeshGate, DEC);
635 IEEE80211_IF_FILE(dot11MeshNolearn, u.mesh.mshcfg.dot11MeshNolearn, DEC);
636 IEEE80211_IF_FILE(dot11MeshConnectedToAuthServer,
637                   u.mesh.mshcfg.dot11MeshConnectedToAuthServer, DEC);
638 #endif
639
640 #define DEBUGFS_ADD_MODE(name, mode) \
641         debugfs_create_file(#name, mode, sdata->vif.debugfs_dir, \
642                             sdata, &name##_ops)
643
644 #define DEBUGFS_ADD(name) DEBUGFS_ADD_MODE(name, 0400)
645
646 static void add_common_files(struct ieee80211_sub_if_data *sdata)
647 {
648         DEBUGFS_ADD(rc_rateidx_mask_2ghz);
649         DEBUGFS_ADD(rc_rateidx_mask_5ghz);
650         DEBUGFS_ADD(rc_rateidx_mcs_mask_2ghz);
651         DEBUGFS_ADD(rc_rateidx_mcs_mask_5ghz);
652         DEBUGFS_ADD(rc_rateidx_vht_mcs_mask_2ghz);
653         DEBUGFS_ADD(rc_rateidx_vht_mcs_mask_5ghz);
654         DEBUGFS_ADD(hw_queues);
655
656         if (sdata->local->ops->wake_tx_queue &&
657             sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
658             sdata->vif.type != NL80211_IFTYPE_NAN)
659                 DEBUGFS_ADD(aqm);
660 }
661
662 static void add_sta_files(struct ieee80211_sub_if_data *sdata)
663 {
664         DEBUGFS_ADD(bssid);
665         DEBUGFS_ADD(aid);
666         DEBUGFS_ADD(beacon_timeout);
667         DEBUGFS_ADD_MODE(smps, 0600);
668         DEBUGFS_ADD_MODE(tkip_mic_test, 0200);
669         DEBUGFS_ADD_MODE(beacon_loss, 0200);
670         DEBUGFS_ADD_MODE(uapsd_queues, 0600);
671         DEBUGFS_ADD_MODE(uapsd_max_sp_len, 0600);
672         DEBUGFS_ADD_MODE(tdls_wider_bw, 0600);
673 }
674
675 static void add_ap_files(struct ieee80211_sub_if_data *sdata)
676 {
677         DEBUGFS_ADD(num_mcast_sta);
678         DEBUGFS_ADD_MODE(smps, 0600);
679         DEBUGFS_ADD(num_sta_ps);
680         DEBUGFS_ADD(dtim_count);
681         DEBUGFS_ADD(num_buffered_multicast);
682         DEBUGFS_ADD_MODE(tkip_mic_test, 0200);
683         DEBUGFS_ADD_MODE(multicast_to_unicast, 0600);
684 }
685
686 static void add_vlan_files(struct ieee80211_sub_if_data *sdata)
687 {
688         /* add num_mcast_sta_vlan using name num_mcast_sta */
689         debugfs_create_file("num_mcast_sta", 0400, sdata->vif.debugfs_dir,
690                             sdata, &num_mcast_sta_vlan_ops);
691 }
692
693 static void add_ibss_files(struct ieee80211_sub_if_data *sdata)
694 {
695         DEBUGFS_ADD_MODE(tsf, 0600);
696 }
697
698 #ifdef CONFIG_MAC80211_MESH
699
700 static void add_mesh_files(struct ieee80211_sub_if_data *sdata)
701 {
702         DEBUGFS_ADD_MODE(tsf, 0600);
703         DEBUGFS_ADD_MODE(estab_plinks, 0400);
704 }
705
706 static void add_mesh_stats(struct ieee80211_sub_if_data *sdata)
707 {
708         struct dentry *dir = debugfs_create_dir("mesh_stats",
709                                                 sdata->vif.debugfs_dir);
710 #define MESHSTATS_ADD(name)\
711         debugfs_create_file(#name, 0400, dir, sdata, &name##_ops)
712
713         MESHSTATS_ADD(fwded_mcast);
714         MESHSTATS_ADD(fwded_unicast);
715         MESHSTATS_ADD(fwded_frames);
716         MESHSTATS_ADD(dropped_frames_ttl);
717         MESHSTATS_ADD(dropped_frames_no_route);
718         MESHSTATS_ADD(dropped_frames_congestion);
719 #undef MESHSTATS_ADD
720 }
721
722 static void add_mesh_config(struct ieee80211_sub_if_data *sdata)
723 {
724         struct dentry *dir = debugfs_create_dir("mesh_config",
725                                                 sdata->vif.debugfs_dir);
726
727 #define MESHPARAMS_ADD(name) \
728         debugfs_create_file(#name, 0600, dir, sdata, &name##_ops)
729
730         MESHPARAMS_ADD(dot11MeshMaxRetries);
731         MESHPARAMS_ADD(dot11MeshRetryTimeout);
732         MESHPARAMS_ADD(dot11MeshConfirmTimeout);
733         MESHPARAMS_ADD(dot11MeshHoldingTimeout);
734         MESHPARAMS_ADD(dot11MeshTTL);
735         MESHPARAMS_ADD(element_ttl);
736         MESHPARAMS_ADD(auto_open_plinks);
737         MESHPARAMS_ADD(dot11MeshMaxPeerLinks);
738         MESHPARAMS_ADD(dot11MeshHWMPactivePathTimeout);
739         MESHPARAMS_ADD(dot11MeshHWMPpreqMinInterval);
740         MESHPARAMS_ADD(dot11MeshHWMPperrMinInterval);
741         MESHPARAMS_ADD(dot11MeshHWMPnetDiameterTraversalTime);
742         MESHPARAMS_ADD(dot11MeshHWMPmaxPREQretries);
743         MESHPARAMS_ADD(path_refresh_time);
744         MESHPARAMS_ADD(min_discovery_timeout);
745         MESHPARAMS_ADD(dot11MeshHWMPRootMode);
746         MESHPARAMS_ADD(dot11MeshHWMPRannInterval);
747         MESHPARAMS_ADD(dot11MeshForwarding);
748         MESHPARAMS_ADD(dot11MeshGateAnnouncementProtocol);
749         MESHPARAMS_ADD(rssi_threshold);
750         MESHPARAMS_ADD(ht_opmode);
751         MESHPARAMS_ADD(dot11MeshHWMPactivePathToRootTimeout);
752         MESHPARAMS_ADD(dot11MeshHWMProotInterval);
753         MESHPARAMS_ADD(dot11MeshHWMPconfirmationInterval);
754         MESHPARAMS_ADD(power_mode);
755         MESHPARAMS_ADD(dot11MeshAwakeWindowDuration);
756         MESHPARAMS_ADD(dot11MeshConnectedToMeshGate);
757         MESHPARAMS_ADD(dot11MeshNolearn);
758         MESHPARAMS_ADD(dot11MeshConnectedToAuthServer);
759 #undef MESHPARAMS_ADD
760 }
761 #endif
762
763 static void add_files(struct ieee80211_sub_if_data *sdata)
764 {
765         if (!sdata->vif.debugfs_dir)
766                 return;
767
768         DEBUGFS_ADD(flags);
769         DEBUGFS_ADD(state);
770         DEBUGFS_ADD(txpower);
771         DEBUGFS_ADD(user_power_level);
772         DEBUGFS_ADD(ap_power_level);
773
774         if (sdata->vif.type != NL80211_IFTYPE_MONITOR)
775                 add_common_files(sdata);
776
777         switch (sdata->vif.type) {
778         case NL80211_IFTYPE_MESH_POINT:
779 #ifdef CONFIG_MAC80211_MESH
780                 add_mesh_files(sdata);
781                 add_mesh_stats(sdata);
782                 add_mesh_config(sdata);
783 #endif
784                 break;
785         case NL80211_IFTYPE_STATION:
786                 add_sta_files(sdata);
787                 break;
788         case NL80211_IFTYPE_ADHOC:
789                 add_ibss_files(sdata);
790                 break;
791         case NL80211_IFTYPE_AP:
792                 add_ap_files(sdata);
793                 break;
794         case NL80211_IFTYPE_AP_VLAN:
795                 add_vlan_files(sdata);
796                 break;
797         default:
798                 break;
799         }
800 }
801
802 void ieee80211_debugfs_add_netdev(struct ieee80211_sub_if_data *sdata)
803 {
804         char buf[10+IFNAMSIZ];
805
806         sprintf(buf, "netdev:%s", sdata->name);
807         sdata->vif.debugfs_dir = debugfs_create_dir(buf,
808                 sdata->local->hw.wiphy->debugfsdir);
809         sdata->debugfs.subdir_stations = debugfs_create_dir("stations",
810                                                         sdata->vif.debugfs_dir);
811         add_files(sdata);
812 }
813
814 void ieee80211_debugfs_remove_netdev(struct ieee80211_sub_if_data *sdata)
815 {
816         if (!sdata->vif.debugfs_dir)
817                 return;
818
819         debugfs_remove_recursive(sdata->vif.debugfs_dir);
820         sdata->vif.debugfs_dir = NULL;
821         sdata->debugfs.subdir_stations = NULL;
822 }
823
824 void ieee80211_debugfs_rename_netdev(struct ieee80211_sub_if_data *sdata)
825 {
826         struct dentry *dir;
827         char buf[10 + IFNAMSIZ];
828
829         dir = sdata->vif.debugfs_dir;
830
831         if (IS_ERR_OR_NULL(dir))
832                 return;
833
834         sprintf(buf, "netdev:%s", sdata->name);
835         debugfs_rename(dir->d_parent, dir, dir->d_parent, buf);
836 }