Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (c) 2006   Jiri Benc <jbenc@suse.cz>
0004  * Copyright 2007   Johannes Berg <johannes@sipsolutions.net>
0005  * Copyright (C) 2020-2022 Intel Corporation
0006  */
0007 
0008 #include <linux/kernel.h>
0009 #include <linux/device.h>
0010 #include <linux/if.h>
0011 #include <linux/if_ether.h>
0012 #include <linux/interrupt.h>
0013 #include <linux/netdevice.h>
0014 #include <linux/rtnetlink.h>
0015 #include <linux/slab.h>
0016 #include <linux/notifier.h>
0017 #include <net/mac80211.h>
0018 #include <net/cfg80211.h>
0019 #include "ieee80211_i.h"
0020 #include "rate.h"
0021 #include "debugfs.h"
0022 #include "debugfs_netdev.h"
0023 #include "driver-ops.h"
0024 
0025 static ssize_t ieee80211_if_read(
0026     struct ieee80211_sub_if_data *sdata,
0027     char __user *userbuf,
0028     size_t count, loff_t *ppos,
0029     ssize_t (*format)(const struct ieee80211_sub_if_data *, char *, int))
0030 {
0031     char buf[200];
0032     ssize_t ret = -EINVAL;
0033 
0034     read_lock(&dev_base_lock);
0035     ret = (*format)(sdata, buf, sizeof(buf));
0036     read_unlock(&dev_base_lock);
0037 
0038     if (ret >= 0)
0039         ret = simple_read_from_buffer(userbuf, count, ppos, buf, ret);
0040 
0041     return ret;
0042 }
0043 
0044 static ssize_t ieee80211_if_write(
0045     struct ieee80211_sub_if_data *sdata,
0046     const char __user *userbuf,
0047     size_t count, loff_t *ppos,
0048     ssize_t (*write)(struct ieee80211_sub_if_data *, const char *, int))
0049 {
0050     char buf[64];
0051     ssize_t ret;
0052 
0053     if (count >= sizeof(buf))
0054         return -E2BIG;
0055 
0056     if (copy_from_user(buf, userbuf, count))
0057         return -EFAULT;
0058     buf[count] = '\0';
0059 
0060     rtnl_lock();
0061     ret = (*write)(sdata, buf, count);
0062     rtnl_unlock();
0063 
0064     return ret;
0065 }
0066 
0067 #define IEEE80211_IF_FMT(name, field, format_string)            \
0068 static ssize_t ieee80211_if_fmt_##name(                 \
0069     const struct ieee80211_sub_if_data *sdata, char *buf,       \
0070     int buflen)                         \
0071 {                                   \
0072     return scnprintf(buf, buflen, format_string, sdata->field); \
0073 }
0074 #define IEEE80211_IF_FMT_DEC(name, field)               \
0075         IEEE80211_IF_FMT(name, field, "%d\n")
0076 #define IEEE80211_IF_FMT_HEX(name, field)               \
0077         IEEE80211_IF_FMT(name, field, "%#x\n")
0078 #define IEEE80211_IF_FMT_LHEX(name, field)              \
0079         IEEE80211_IF_FMT(name, field, "%#lx\n")
0080 
0081 #define IEEE80211_IF_FMT_HEXARRAY(name, field)              \
0082 static ssize_t ieee80211_if_fmt_##name(                 \
0083     const struct ieee80211_sub_if_data *sdata,          \
0084     char *buf, int buflen)                      \
0085 {                                   \
0086     char *p = buf;                          \
0087     int i;                              \
0088     for (i = 0; i < sizeof(sdata->field); i++) {            \
0089         p += scnprintf(p, buflen + buf - p, "%.2x ",        \
0090                  sdata->field[i]);          \
0091     }                               \
0092     p += scnprintf(p, buflen + buf - p, "\n");          \
0093     return p - buf;                         \
0094 }
0095 
0096 #define IEEE80211_IF_FMT_ATOMIC(name, field)                \
0097 static ssize_t ieee80211_if_fmt_##name(                 \
0098     const struct ieee80211_sub_if_data *sdata,          \
0099     char *buf, int buflen)                      \
0100 {                                   \
0101     return scnprintf(buf, buflen, "%d\n", atomic_read(&sdata->field));\
0102 }
0103 
0104 #define IEEE80211_IF_FMT_MAC(name, field)               \
0105 static ssize_t ieee80211_if_fmt_##name(                 \
0106     const struct ieee80211_sub_if_data *sdata, char *buf,       \
0107     int buflen)                         \
0108 {                                   \
0109     return scnprintf(buf, buflen, "%pM\n", sdata->field);       \
0110 }
0111 
0112 #define IEEE80211_IF_FMT_JIFFIES_TO_MS(name, field)         \
0113 static ssize_t ieee80211_if_fmt_##name(                 \
0114     const struct ieee80211_sub_if_data *sdata,          \
0115     char *buf, int buflen)                      \
0116 {                                   \
0117     return scnprintf(buf, buflen, "%d\n",               \
0118              jiffies_to_msecs(sdata->field));       \
0119 }
0120 
0121 #define _IEEE80211_IF_FILE_OPS(name, _read, _write)         \
0122 static const struct file_operations name##_ops = {          \
0123     .read = (_read),                        \
0124     .write = (_write),                      \
0125     .open = simple_open,                        \
0126     .llseek = generic_file_llseek,                  \
0127 }
0128 
0129 #define _IEEE80211_IF_FILE_R_FN(name)                   \
0130 static ssize_t ieee80211_if_read_##name(struct file *file,      \
0131                     char __user *userbuf,       \
0132                     size_t count, loff_t *ppos) \
0133 {                                   \
0134     return ieee80211_if_read(file->private_data,            \
0135                  userbuf, count, ppos,          \
0136                  ieee80211_if_fmt_##name);      \
0137 }
0138 
0139 #define _IEEE80211_IF_FILE_W_FN(name)                   \
0140 static ssize_t ieee80211_if_write_##name(struct file *file,     \
0141                      const char __user *userbuf,    \
0142                      size_t count, loff_t *ppos)    \
0143 {                                   \
0144     return ieee80211_if_write(file->private_data, userbuf, count,   \
0145                   ppos, ieee80211_if_parse_##name); \
0146 }
0147 
0148 #define IEEE80211_IF_FILE_R(name)                   \
0149     _IEEE80211_IF_FILE_R_FN(name)                   \
0150     _IEEE80211_IF_FILE_OPS(name, ieee80211_if_read_##name, NULL)
0151 
0152 #define IEEE80211_IF_FILE_W(name)                   \
0153     _IEEE80211_IF_FILE_W_FN(name)                   \
0154     _IEEE80211_IF_FILE_OPS(name, NULL, ieee80211_if_write_##name)
0155 
0156 #define IEEE80211_IF_FILE_RW(name)                  \
0157     _IEEE80211_IF_FILE_R_FN(name)                   \
0158     _IEEE80211_IF_FILE_W_FN(name)                   \
0159     _IEEE80211_IF_FILE_OPS(name, ieee80211_if_read_##name,      \
0160                    ieee80211_if_write_##name)
0161 
0162 #define IEEE80211_IF_FILE(name, field, format)              \
0163     IEEE80211_IF_FMT_##format(name, field)              \
0164     IEEE80211_IF_FILE_R(name)
0165 
0166 /* common attributes */
0167 IEEE80211_IF_FILE(rc_rateidx_mask_2ghz, rc_rateidx_mask[NL80211_BAND_2GHZ],
0168           HEX);
0169 IEEE80211_IF_FILE(rc_rateidx_mask_5ghz, rc_rateidx_mask[NL80211_BAND_5GHZ],
0170           HEX);
0171 IEEE80211_IF_FILE(rc_rateidx_mcs_mask_2ghz,
0172           rc_rateidx_mcs_mask[NL80211_BAND_2GHZ], HEXARRAY);
0173 IEEE80211_IF_FILE(rc_rateidx_mcs_mask_5ghz,
0174           rc_rateidx_mcs_mask[NL80211_BAND_5GHZ], HEXARRAY);
0175 
0176 static ssize_t ieee80211_if_fmt_rc_rateidx_vht_mcs_mask_2ghz(
0177                 const struct ieee80211_sub_if_data *sdata,
0178                 char *buf, int buflen)
0179 {
0180     int i, len = 0;
0181     const u16 *mask = sdata->rc_rateidx_vht_mcs_mask[NL80211_BAND_2GHZ];
0182 
0183     for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
0184         len += scnprintf(buf + len, buflen - len, "%04x ", mask[i]);
0185     len += scnprintf(buf + len, buflen - len, "\n");
0186 
0187     return len;
0188 }
0189 
0190 IEEE80211_IF_FILE_R(rc_rateidx_vht_mcs_mask_2ghz);
0191 
0192 static ssize_t ieee80211_if_fmt_rc_rateidx_vht_mcs_mask_5ghz(
0193                 const struct ieee80211_sub_if_data *sdata,
0194                 char *buf, int buflen)
0195 {
0196     int i, len = 0;
0197     const u16 *mask = sdata->rc_rateidx_vht_mcs_mask[NL80211_BAND_5GHZ];
0198 
0199     for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
0200         len += scnprintf(buf + len, buflen - len, "%04x ", mask[i]);
0201     len += scnprintf(buf + len, buflen - len, "\n");
0202 
0203     return len;
0204 }
0205 
0206 IEEE80211_IF_FILE_R(rc_rateidx_vht_mcs_mask_5ghz);
0207 
0208 IEEE80211_IF_FILE(flags, flags, HEX);
0209 IEEE80211_IF_FILE(state, state, LHEX);
0210 IEEE80211_IF_FILE(txpower, vif.bss_conf.txpower, DEC);
0211 IEEE80211_IF_FILE(ap_power_level, deflink.ap_power_level, DEC);
0212 IEEE80211_IF_FILE(user_power_level, deflink.user_power_level, DEC);
0213 
0214 static ssize_t
0215 ieee80211_if_fmt_hw_queues(const struct ieee80211_sub_if_data *sdata,
0216                char *buf, int buflen)
0217 {
0218     int len;
0219 
0220     len = scnprintf(buf, buflen, "AC queues: VO:%d VI:%d BE:%d BK:%d\n",
0221             sdata->vif.hw_queue[IEEE80211_AC_VO],
0222             sdata->vif.hw_queue[IEEE80211_AC_VI],
0223             sdata->vif.hw_queue[IEEE80211_AC_BE],
0224             sdata->vif.hw_queue[IEEE80211_AC_BK]);
0225 
0226     if (sdata->vif.type == NL80211_IFTYPE_AP)
0227         len += scnprintf(buf + len, buflen - len, "cab queue: %d\n",
0228                  sdata->vif.cab_queue);
0229 
0230     return len;
0231 }
0232 IEEE80211_IF_FILE_R(hw_queues);
0233 
0234 /* STA attributes */
0235 IEEE80211_IF_FILE(bssid, deflink.u.mgd.bssid, MAC);
0236 IEEE80211_IF_FILE(aid, vif.cfg.aid, DEC);
0237 IEEE80211_IF_FILE(beacon_timeout, u.mgd.beacon_timeout, JIFFIES_TO_MS);
0238 
0239 static int ieee80211_set_smps(struct ieee80211_sub_if_data *sdata,
0240                   enum ieee80211_smps_mode smps_mode)
0241 {
0242     struct ieee80211_local *local = sdata->local;
0243     int err;
0244 
0245     if (!(local->hw.wiphy->features & NL80211_FEATURE_STATIC_SMPS) &&
0246         smps_mode == IEEE80211_SMPS_STATIC)
0247         return -EINVAL;
0248 
0249     /* auto should be dynamic if in PS mode */
0250     if (!(local->hw.wiphy->features & NL80211_FEATURE_DYNAMIC_SMPS) &&
0251         (smps_mode == IEEE80211_SMPS_DYNAMIC ||
0252          smps_mode == IEEE80211_SMPS_AUTOMATIC))
0253         return -EINVAL;
0254 
0255     if (sdata->vif.type != NL80211_IFTYPE_STATION)
0256         return -EOPNOTSUPP;
0257 
0258     sdata_lock(sdata);
0259     err = __ieee80211_request_smps_mgd(sdata, &sdata->deflink, smps_mode);
0260     sdata_unlock(sdata);
0261 
0262     return err;
0263 }
0264 
0265 static const char *smps_modes[IEEE80211_SMPS_NUM_MODES] = {
0266     [IEEE80211_SMPS_AUTOMATIC] = "auto",
0267     [IEEE80211_SMPS_OFF] = "off",
0268     [IEEE80211_SMPS_STATIC] = "static",
0269     [IEEE80211_SMPS_DYNAMIC] = "dynamic",
0270 };
0271 
0272 static ssize_t ieee80211_if_fmt_smps(const struct ieee80211_sub_if_data *sdata,
0273                      char *buf, int buflen)
0274 {
0275     if (sdata->vif.type == NL80211_IFTYPE_STATION)
0276         return snprintf(buf, buflen, "request: %s\nused: %s\n",
0277                 smps_modes[sdata->deflink.u.mgd.req_smps],
0278                 smps_modes[sdata->deflink.smps_mode]);
0279     return -EINVAL;
0280 }
0281 
0282 static ssize_t ieee80211_if_parse_smps(struct ieee80211_sub_if_data *sdata,
0283                        const char *buf, int buflen)
0284 {
0285     enum ieee80211_smps_mode mode;
0286 
0287     for (mode = 0; mode < IEEE80211_SMPS_NUM_MODES; mode++) {
0288         if (strncmp(buf, smps_modes[mode], buflen) == 0) {
0289             int err = ieee80211_set_smps(sdata, mode);
0290             if (!err)
0291                 return buflen;
0292             return err;
0293         }
0294     }
0295 
0296     return -EINVAL;
0297 }
0298 IEEE80211_IF_FILE_RW(smps);
0299 
0300 static ssize_t ieee80211_if_parse_tkip_mic_test(
0301     struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
0302 {
0303     struct ieee80211_local *local = sdata->local;
0304     u8 addr[ETH_ALEN];
0305     struct sk_buff *skb;
0306     struct ieee80211_hdr *hdr;
0307     __le16 fc;
0308 
0309     if (!mac_pton(buf, addr))
0310         return -EINVAL;
0311 
0312     if (!ieee80211_sdata_running(sdata))
0313         return -ENOTCONN;
0314 
0315     skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24 + 100);
0316     if (!skb)
0317         return -ENOMEM;
0318     skb_reserve(skb, local->hw.extra_tx_headroom);
0319 
0320     hdr = skb_put_zero(skb, 24);
0321     fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA);
0322 
0323     switch (sdata->vif.type) {
0324     case NL80211_IFTYPE_AP:
0325         fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
0326         /* DA BSSID SA */
0327         memcpy(hdr->addr1, addr, ETH_ALEN);
0328         memcpy(hdr->addr2, sdata->vif.addr, ETH_ALEN);
0329         memcpy(hdr->addr3, sdata->vif.addr, ETH_ALEN);
0330         break;
0331     case NL80211_IFTYPE_STATION:
0332         fc |= cpu_to_le16(IEEE80211_FCTL_TODS);
0333         /* BSSID SA DA */
0334         sdata_lock(sdata);
0335         if (!sdata->u.mgd.associated) {
0336             sdata_unlock(sdata);
0337             dev_kfree_skb(skb);
0338             return -ENOTCONN;
0339         }
0340         memcpy(hdr->addr1, sdata->deflink.u.mgd.bssid, ETH_ALEN);
0341         memcpy(hdr->addr2, sdata->vif.addr, ETH_ALEN);
0342         memcpy(hdr->addr3, addr, ETH_ALEN);
0343         sdata_unlock(sdata);
0344         break;
0345     default:
0346         dev_kfree_skb(skb);
0347         return -EOPNOTSUPP;
0348     }
0349     hdr->frame_control = fc;
0350 
0351     /*
0352      * Add some length to the test frame to make it look bit more valid.
0353      * The exact contents does not matter since the recipient is required
0354      * to drop this because of the Michael MIC failure.
0355      */
0356     skb_put_zero(skb, 50);
0357 
0358     IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_TKIP_MIC_FAILURE;
0359 
0360     ieee80211_tx_skb(sdata, skb);
0361 
0362     return buflen;
0363 }
0364 IEEE80211_IF_FILE_W(tkip_mic_test);
0365 
0366 static ssize_t ieee80211_if_parse_beacon_loss(
0367     struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
0368 {
0369     if (!ieee80211_sdata_running(sdata) || !sdata->vif.cfg.assoc)
0370         return -ENOTCONN;
0371 
0372     ieee80211_beacon_loss(&sdata->vif);
0373 
0374     return buflen;
0375 }
0376 IEEE80211_IF_FILE_W(beacon_loss);
0377 
0378 static ssize_t ieee80211_if_fmt_uapsd_queues(
0379     const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
0380 {
0381     const struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
0382 
0383     return snprintf(buf, buflen, "0x%x\n", ifmgd->uapsd_queues);
0384 }
0385 
0386 static ssize_t ieee80211_if_parse_uapsd_queues(
0387     struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
0388 {
0389     struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
0390     u8 val;
0391     int ret;
0392 
0393     ret = kstrtou8(buf, 0, &val);
0394     if (ret)
0395         return ret;
0396 
0397     if (val & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
0398         return -ERANGE;
0399 
0400     ifmgd->uapsd_queues = val;
0401 
0402     return buflen;
0403 }
0404 IEEE80211_IF_FILE_RW(uapsd_queues);
0405 
0406 static ssize_t ieee80211_if_fmt_uapsd_max_sp_len(
0407     const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
0408 {
0409     const struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
0410 
0411     return snprintf(buf, buflen, "0x%x\n", ifmgd->uapsd_max_sp_len);
0412 }
0413 
0414 static ssize_t ieee80211_if_parse_uapsd_max_sp_len(
0415     struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
0416 {
0417     struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
0418     unsigned long val;
0419     int ret;
0420 
0421     ret = kstrtoul(buf, 0, &val);
0422     if (ret)
0423         return -EINVAL;
0424 
0425     if (val & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
0426         return -ERANGE;
0427 
0428     ifmgd->uapsd_max_sp_len = val;
0429 
0430     return buflen;
0431 }
0432 IEEE80211_IF_FILE_RW(uapsd_max_sp_len);
0433 
0434 static ssize_t ieee80211_if_fmt_tdls_wider_bw(
0435     const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
0436 {
0437     const struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
0438     bool tdls_wider_bw;
0439 
0440     tdls_wider_bw = ieee80211_hw_check(&sdata->local->hw, TDLS_WIDER_BW) &&
0441             !ifmgd->tdls_wider_bw_prohibited;
0442 
0443     return snprintf(buf, buflen, "%d\n", tdls_wider_bw);
0444 }
0445 
0446 static ssize_t ieee80211_if_parse_tdls_wider_bw(
0447     struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
0448 {
0449     struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
0450     u8 val;
0451     int ret;
0452 
0453     ret = kstrtou8(buf, 0, &val);
0454     if (ret)
0455         return ret;
0456 
0457     ifmgd->tdls_wider_bw_prohibited = !val;
0458     return buflen;
0459 }
0460 IEEE80211_IF_FILE_RW(tdls_wider_bw);
0461 
0462 /* AP attributes */
0463 IEEE80211_IF_FILE(num_mcast_sta, u.ap.num_mcast_sta, ATOMIC);
0464 IEEE80211_IF_FILE(num_sta_ps, u.ap.ps.num_sta_ps, ATOMIC);
0465 IEEE80211_IF_FILE(dtim_count, u.ap.ps.dtim_count, DEC);
0466 IEEE80211_IF_FILE(num_mcast_sta_vlan, u.vlan.num_mcast_sta, ATOMIC);
0467 
0468 static ssize_t ieee80211_if_fmt_num_buffered_multicast(
0469     const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
0470 {
0471     return scnprintf(buf, buflen, "%u\n",
0472              skb_queue_len(&sdata->u.ap.ps.bc_buf));
0473 }
0474 IEEE80211_IF_FILE_R(num_buffered_multicast);
0475 
0476 static ssize_t ieee80211_if_fmt_aqm(
0477     const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
0478 {
0479     struct ieee80211_local *local = sdata->local;
0480     struct txq_info *txqi;
0481     int len;
0482 
0483     if (!sdata->vif.txq)
0484         return 0;
0485 
0486     txqi = to_txq_info(sdata->vif.txq);
0487 
0488     spin_lock_bh(&local->fq.lock);
0489     rcu_read_lock();
0490 
0491     len = scnprintf(buf,
0492             buflen,
0493             "ac backlog-bytes backlog-packets new-flows drops marks overlimit collisions tx-bytes tx-packets\n"
0494             "%u %u %u %u %u %u %u %u %u %u\n",
0495             txqi->txq.ac,
0496             txqi->tin.backlog_bytes,
0497             txqi->tin.backlog_packets,
0498             txqi->tin.flows,
0499             txqi->cstats.drop_count,
0500             txqi->cstats.ecn_mark,
0501             txqi->tin.overlimit,
0502             txqi->tin.collisions,
0503             txqi->tin.tx_bytes,
0504             txqi->tin.tx_packets);
0505 
0506     rcu_read_unlock();
0507     spin_unlock_bh(&local->fq.lock);
0508 
0509     return len;
0510 }
0511 IEEE80211_IF_FILE_R(aqm);
0512 
0513 IEEE80211_IF_FILE(multicast_to_unicast, u.ap.multicast_to_unicast, HEX);
0514 
0515 /* IBSS attributes */
0516 static ssize_t ieee80211_if_fmt_tsf(
0517     const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
0518 {
0519     struct ieee80211_local *local = sdata->local;
0520     u64 tsf;
0521 
0522     tsf = drv_get_tsf(local, (struct ieee80211_sub_if_data *)sdata);
0523 
0524     return scnprintf(buf, buflen, "0x%016llx\n", (unsigned long long) tsf);
0525 }
0526 
0527 static ssize_t ieee80211_if_parse_tsf(
0528     struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
0529 {
0530     struct ieee80211_local *local = sdata->local;
0531     unsigned long long tsf;
0532     int ret;
0533     int tsf_is_delta = 0;
0534 
0535     if (strncmp(buf, "reset", 5) == 0) {
0536         if (local->ops->reset_tsf) {
0537             drv_reset_tsf(local, sdata);
0538             wiphy_info(local->hw.wiphy, "debugfs reset TSF\n");
0539         }
0540     } else {
0541         if (buflen > 10 && buf[1] == '=') {
0542             if (buf[0] == '+')
0543                 tsf_is_delta = 1;
0544             else if (buf[0] == '-')
0545                 tsf_is_delta = -1;
0546             else
0547                 return -EINVAL;
0548             buf += 2;
0549         }
0550         ret = kstrtoull(buf, 10, &tsf);
0551         if (ret < 0)
0552             return ret;
0553         if (tsf_is_delta && local->ops->offset_tsf) {
0554             drv_offset_tsf(local, sdata, tsf_is_delta * tsf);
0555             wiphy_info(local->hw.wiphy,
0556                    "debugfs offset TSF by %018lld\n",
0557                    tsf_is_delta * tsf);
0558         } else if (local->ops->set_tsf) {
0559             if (tsf_is_delta)
0560                 tsf = drv_get_tsf(local, sdata) +
0561                       tsf_is_delta * tsf;
0562             drv_set_tsf(local, sdata, tsf);
0563             wiphy_info(local->hw.wiphy,
0564                    "debugfs set TSF to %#018llx\n", tsf);
0565         }
0566     }
0567 
0568     ieee80211_recalc_dtim(local, sdata);
0569     return buflen;
0570 }
0571 IEEE80211_IF_FILE_RW(tsf);
0572 
0573 
0574 #ifdef CONFIG_MAC80211_MESH
0575 IEEE80211_IF_FILE(estab_plinks, u.mesh.estab_plinks, ATOMIC);
0576 
0577 /* Mesh stats attributes */
0578 IEEE80211_IF_FILE(fwded_mcast, u.mesh.mshstats.fwded_mcast, DEC);
0579 IEEE80211_IF_FILE(fwded_unicast, u.mesh.mshstats.fwded_unicast, DEC);
0580 IEEE80211_IF_FILE(fwded_frames, u.mesh.mshstats.fwded_frames, DEC);
0581 IEEE80211_IF_FILE(dropped_frames_ttl, u.mesh.mshstats.dropped_frames_ttl, DEC);
0582 IEEE80211_IF_FILE(dropped_frames_congestion,
0583           u.mesh.mshstats.dropped_frames_congestion, DEC);
0584 IEEE80211_IF_FILE(dropped_frames_no_route,
0585           u.mesh.mshstats.dropped_frames_no_route, DEC);
0586 
0587 /* Mesh parameters */
0588 IEEE80211_IF_FILE(dot11MeshMaxRetries,
0589           u.mesh.mshcfg.dot11MeshMaxRetries, DEC);
0590 IEEE80211_IF_FILE(dot11MeshRetryTimeout,
0591           u.mesh.mshcfg.dot11MeshRetryTimeout, DEC);
0592 IEEE80211_IF_FILE(dot11MeshConfirmTimeout,
0593           u.mesh.mshcfg.dot11MeshConfirmTimeout, DEC);
0594 IEEE80211_IF_FILE(dot11MeshHoldingTimeout,
0595           u.mesh.mshcfg.dot11MeshHoldingTimeout, DEC);
0596 IEEE80211_IF_FILE(dot11MeshTTL, u.mesh.mshcfg.dot11MeshTTL, DEC);
0597 IEEE80211_IF_FILE(element_ttl, u.mesh.mshcfg.element_ttl, DEC);
0598 IEEE80211_IF_FILE(auto_open_plinks, u.mesh.mshcfg.auto_open_plinks, DEC);
0599 IEEE80211_IF_FILE(dot11MeshMaxPeerLinks,
0600           u.mesh.mshcfg.dot11MeshMaxPeerLinks, DEC);
0601 IEEE80211_IF_FILE(dot11MeshHWMPactivePathTimeout,
0602           u.mesh.mshcfg.dot11MeshHWMPactivePathTimeout, DEC);
0603 IEEE80211_IF_FILE(dot11MeshHWMPpreqMinInterval,
0604           u.mesh.mshcfg.dot11MeshHWMPpreqMinInterval, DEC);
0605 IEEE80211_IF_FILE(dot11MeshHWMPperrMinInterval,
0606           u.mesh.mshcfg.dot11MeshHWMPperrMinInterval, DEC);
0607 IEEE80211_IF_FILE(dot11MeshHWMPnetDiameterTraversalTime,
0608           u.mesh.mshcfg.dot11MeshHWMPnetDiameterTraversalTime, DEC);
0609 IEEE80211_IF_FILE(dot11MeshHWMPmaxPREQretries,
0610           u.mesh.mshcfg.dot11MeshHWMPmaxPREQretries, DEC);
0611 IEEE80211_IF_FILE(path_refresh_time,
0612           u.mesh.mshcfg.path_refresh_time, DEC);
0613 IEEE80211_IF_FILE(min_discovery_timeout,
0614           u.mesh.mshcfg.min_discovery_timeout, DEC);
0615 IEEE80211_IF_FILE(dot11MeshHWMPRootMode,
0616           u.mesh.mshcfg.dot11MeshHWMPRootMode, DEC);
0617 IEEE80211_IF_FILE(dot11MeshGateAnnouncementProtocol,
0618           u.mesh.mshcfg.dot11MeshGateAnnouncementProtocol, DEC);
0619 IEEE80211_IF_FILE(dot11MeshHWMPRannInterval,
0620           u.mesh.mshcfg.dot11MeshHWMPRannInterval, DEC);
0621 IEEE80211_IF_FILE(dot11MeshForwarding, u.mesh.mshcfg.dot11MeshForwarding, DEC);
0622 IEEE80211_IF_FILE(rssi_threshold, u.mesh.mshcfg.rssi_threshold, DEC);
0623 IEEE80211_IF_FILE(ht_opmode, u.mesh.mshcfg.ht_opmode, DEC);
0624 IEEE80211_IF_FILE(dot11MeshHWMPactivePathToRootTimeout,
0625           u.mesh.mshcfg.dot11MeshHWMPactivePathToRootTimeout, DEC);
0626 IEEE80211_IF_FILE(dot11MeshHWMProotInterval,
0627           u.mesh.mshcfg.dot11MeshHWMProotInterval, DEC);
0628 IEEE80211_IF_FILE(dot11MeshHWMPconfirmationInterval,
0629           u.mesh.mshcfg.dot11MeshHWMPconfirmationInterval, DEC);
0630 IEEE80211_IF_FILE(power_mode, u.mesh.mshcfg.power_mode, DEC);
0631 IEEE80211_IF_FILE(dot11MeshAwakeWindowDuration,
0632           u.mesh.mshcfg.dot11MeshAwakeWindowDuration, DEC);
0633 IEEE80211_IF_FILE(dot11MeshConnectedToMeshGate,
0634           u.mesh.mshcfg.dot11MeshConnectedToMeshGate, DEC);
0635 IEEE80211_IF_FILE(dot11MeshNolearn, u.mesh.mshcfg.dot11MeshNolearn, DEC);
0636 IEEE80211_IF_FILE(dot11MeshConnectedToAuthServer,
0637           u.mesh.mshcfg.dot11MeshConnectedToAuthServer, DEC);
0638 #endif
0639 
0640 #define DEBUGFS_ADD_MODE(name, mode) \
0641     debugfs_create_file(#name, mode, sdata->vif.debugfs_dir, \
0642                 sdata, &name##_ops)
0643 
0644 #define DEBUGFS_ADD(name) DEBUGFS_ADD_MODE(name, 0400)
0645 
0646 static void add_common_files(struct ieee80211_sub_if_data *sdata)
0647 {
0648     DEBUGFS_ADD(rc_rateidx_mask_2ghz);
0649     DEBUGFS_ADD(rc_rateidx_mask_5ghz);
0650     DEBUGFS_ADD(rc_rateidx_mcs_mask_2ghz);
0651     DEBUGFS_ADD(rc_rateidx_mcs_mask_5ghz);
0652     DEBUGFS_ADD(rc_rateidx_vht_mcs_mask_2ghz);
0653     DEBUGFS_ADD(rc_rateidx_vht_mcs_mask_5ghz);
0654     DEBUGFS_ADD(hw_queues);
0655 
0656     if (sdata->local->ops->wake_tx_queue &&
0657         sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
0658         sdata->vif.type != NL80211_IFTYPE_NAN)
0659         DEBUGFS_ADD(aqm);
0660 }
0661 
0662 static void add_sta_files(struct ieee80211_sub_if_data *sdata)
0663 {
0664     DEBUGFS_ADD(bssid);
0665     DEBUGFS_ADD(aid);
0666     DEBUGFS_ADD(beacon_timeout);
0667     DEBUGFS_ADD_MODE(smps, 0600);
0668     DEBUGFS_ADD_MODE(tkip_mic_test, 0200);
0669     DEBUGFS_ADD_MODE(beacon_loss, 0200);
0670     DEBUGFS_ADD_MODE(uapsd_queues, 0600);
0671     DEBUGFS_ADD_MODE(uapsd_max_sp_len, 0600);
0672     DEBUGFS_ADD_MODE(tdls_wider_bw, 0600);
0673 }
0674 
0675 static void add_ap_files(struct ieee80211_sub_if_data *sdata)
0676 {
0677     DEBUGFS_ADD(num_mcast_sta);
0678     DEBUGFS_ADD_MODE(smps, 0600);
0679     DEBUGFS_ADD(num_sta_ps);
0680     DEBUGFS_ADD(dtim_count);
0681     DEBUGFS_ADD(num_buffered_multicast);
0682     DEBUGFS_ADD_MODE(tkip_mic_test, 0200);
0683     DEBUGFS_ADD_MODE(multicast_to_unicast, 0600);
0684 }
0685 
0686 static void add_vlan_files(struct ieee80211_sub_if_data *sdata)
0687 {
0688     /* add num_mcast_sta_vlan using name num_mcast_sta */
0689     debugfs_create_file("num_mcast_sta", 0400, sdata->vif.debugfs_dir,
0690                 sdata, &num_mcast_sta_vlan_ops);
0691 }
0692 
0693 static void add_ibss_files(struct ieee80211_sub_if_data *sdata)
0694 {
0695     DEBUGFS_ADD_MODE(tsf, 0600);
0696 }
0697 
0698 #ifdef CONFIG_MAC80211_MESH
0699 
0700 static void add_mesh_files(struct ieee80211_sub_if_data *sdata)
0701 {
0702     DEBUGFS_ADD_MODE(tsf, 0600);
0703     DEBUGFS_ADD_MODE(estab_plinks, 0400);
0704 }
0705 
0706 static void add_mesh_stats(struct ieee80211_sub_if_data *sdata)
0707 {
0708     struct dentry *dir = debugfs_create_dir("mesh_stats",
0709                         sdata->vif.debugfs_dir);
0710 #define MESHSTATS_ADD(name)\
0711     debugfs_create_file(#name, 0400, dir, sdata, &name##_ops)
0712 
0713     MESHSTATS_ADD(fwded_mcast);
0714     MESHSTATS_ADD(fwded_unicast);
0715     MESHSTATS_ADD(fwded_frames);
0716     MESHSTATS_ADD(dropped_frames_ttl);
0717     MESHSTATS_ADD(dropped_frames_no_route);
0718     MESHSTATS_ADD(dropped_frames_congestion);
0719 #undef MESHSTATS_ADD
0720 }
0721 
0722 static void add_mesh_config(struct ieee80211_sub_if_data *sdata)
0723 {
0724     struct dentry *dir = debugfs_create_dir("mesh_config",
0725                         sdata->vif.debugfs_dir);
0726 
0727 #define MESHPARAMS_ADD(name) \
0728     debugfs_create_file(#name, 0600, dir, sdata, &name##_ops)
0729 
0730     MESHPARAMS_ADD(dot11MeshMaxRetries);
0731     MESHPARAMS_ADD(dot11MeshRetryTimeout);
0732     MESHPARAMS_ADD(dot11MeshConfirmTimeout);
0733     MESHPARAMS_ADD(dot11MeshHoldingTimeout);
0734     MESHPARAMS_ADD(dot11MeshTTL);
0735     MESHPARAMS_ADD(element_ttl);
0736     MESHPARAMS_ADD(auto_open_plinks);
0737     MESHPARAMS_ADD(dot11MeshMaxPeerLinks);
0738     MESHPARAMS_ADD(dot11MeshHWMPactivePathTimeout);
0739     MESHPARAMS_ADD(dot11MeshHWMPpreqMinInterval);
0740     MESHPARAMS_ADD(dot11MeshHWMPperrMinInterval);
0741     MESHPARAMS_ADD(dot11MeshHWMPnetDiameterTraversalTime);
0742     MESHPARAMS_ADD(dot11MeshHWMPmaxPREQretries);
0743     MESHPARAMS_ADD(path_refresh_time);
0744     MESHPARAMS_ADD(min_discovery_timeout);
0745     MESHPARAMS_ADD(dot11MeshHWMPRootMode);
0746     MESHPARAMS_ADD(dot11MeshHWMPRannInterval);
0747     MESHPARAMS_ADD(dot11MeshForwarding);
0748     MESHPARAMS_ADD(dot11MeshGateAnnouncementProtocol);
0749     MESHPARAMS_ADD(rssi_threshold);
0750     MESHPARAMS_ADD(ht_opmode);
0751     MESHPARAMS_ADD(dot11MeshHWMPactivePathToRootTimeout);
0752     MESHPARAMS_ADD(dot11MeshHWMProotInterval);
0753     MESHPARAMS_ADD(dot11MeshHWMPconfirmationInterval);
0754     MESHPARAMS_ADD(power_mode);
0755     MESHPARAMS_ADD(dot11MeshAwakeWindowDuration);
0756     MESHPARAMS_ADD(dot11MeshConnectedToMeshGate);
0757     MESHPARAMS_ADD(dot11MeshNolearn);
0758     MESHPARAMS_ADD(dot11MeshConnectedToAuthServer);
0759 #undef MESHPARAMS_ADD
0760 }
0761 #endif
0762 
0763 static void add_files(struct ieee80211_sub_if_data *sdata)
0764 {
0765     if (!sdata->vif.debugfs_dir)
0766         return;
0767 
0768     DEBUGFS_ADD(flags);
0769     DEBUGFS_ADD(state);
0770     DEBUGFS_ADD(txpower);
0771     DEBUGFS_ADD(user_power_level);
0772     DEBUGFS_ADD(ap_power_level);
0773 
0774     if (sdata->vif.type != NL80211_IFTYPE_MONITOR)
0775         add_common_files(sdata);
0776 
0777     switch (sdata->vif.type) {
0778     case NL80211_IFTYPE_MESH_POINT:
0779 #ifdef CONFIG_MAC80211_MESH
0780         add_mesh_files(sdata);
0781         add_mesh_stats(sdata);
0782         add_mesh_config(sdata);
0783 #endif
0784         break;
0785     case NL80211_IFTYPE_STATION:
0786         add_sta_files(sdata);
0787         break;
0788     case NL80211_IFTYPE_ADHOC:
0789         add_ibss_files(sdata);
0790         break;
0791     case NL80211_IFTYPE_AP:
0792         add_ap_files(sdata);
0793         break;
0794     case NL80211_IFTYPE_AP_VLAN:
0795         add_vlan_files(sdata);
0796         break;
0797     default:
0798         break;
0799     }
0800 }
0801 
0802 void ieee80211_debugfs_add_netdev(struct ieee80211_sub_if_data *sdata)
0803 {
0804     char buf[10+IFNAMSIZ];
0805 
0806     sprintf(buf, "netdev:%s", sdata->name);
0807     sdata->vif.debugfs_dir = debugfs_create_dir(buf,
0808         sdata->local->hw.wiphy->debugfsdir);
0809     sdata->debugfs.subdir_stations = debugfs_create_dir("stations",
0810                             sdata->vif.debugfs_dir);
0811     add_files(sdata);
0812 }
0813 
0814 void ieee80211_debugfs_remove_netdev(struct ieee80211_sub_if_data *sdata)
0815 {
0816     if (!sdata->vif.debugfs_dir)
0817         return;
0818 
0819     debugfs_remove_recursive(sdata->vif.debugfs_dir);
0820     sdata->vif.debugfs_dir = NULL;
0821     sdata->debugfs.subdir_stations = NULL;
0822 }
0823 
0824 void ieee80211_debugfs_rename_netdev(struct ieee80211_sub_if_data *sdata)
0825 {
0826     struct dentry *dir;
0827     char buf[10 + IFNAMSIZ];
0828 
0829     dir = sdata->vif.debugfs_dir;
0830 
0831     if (IS_ERR_OR_NULL(dir))
0832         return;
0833 
0834     sprintf(buf, "netdev:%s", sdata->name);
0835     debugfs_rename(dir->d_parent, dir, dir->d_parent, buf);
0836 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!