drivers/net/wireless/mediatek/mt76/mt7615/debugfs.c

   1 // SPDX-License-Identifier: ISC
   2
   3 #include "mt7615.h"
   4
   5 static int
   6 mt7615_radar_pattern_set(void *data, u64 val)
   7 {
   8         struct mt7615_dev *dev = data;
   9         int err;
  10
  11         if (!mt7615_wait_for_mcu_init(dev))
  12                 return 0;
  13
  14         mt7615_mutex_acquire(dev);
  15         err = mt7615_mcu_rdd_send_pattern(dev);
  16         mt7615_mutex_release(dev);
  17
  18         return err;
  19 }
  20
  21 DEFINE_DEBUGFS_ATTRIBUTE(fops_radar_pattern, NULL,
  22                          mt7615_radar_pattern_set, "%lld\n");
  23
  24 static int mt7615_config(void *data, u64 val)
  25 {
  26         struct mt7615_dev *dev = data;
  27         int ret;
  28
  29         mt7615_mutex_acquire(dev);
  30         ret = mt76_connac_mcu_chip_config(&dev->mt76);
  31         mt7615_mutex_release(dev);
  32
  33         return ret;
  34 }
  35
  36 DEFINE_DEBUGFS_ATTRIBUTE(fops_config, NULL, mt7615_config, "%lld\n");
  37
  38 static int
  39 mt7615_scs_set(void *data, u64 val)
  40 {
  41         struct mt7615_dev *dev = data;
  42         struct mt7615_phy *ext_phy;
  43
  44         if (!mt7615_wait_for_mcu_init(dev))
  45                 return 0;
  46
  47         mt7615_mac_set_scs(&dev->phy, val);
  48         ext_phy = mt7615_ext_phy(dev);
  49         if (ext_phy)
  50                 mt7615_mac_set_scs(ext_phy, val);
  51
  52         return 0;
  53 }
  54
  55 static int
  56 mt7615_scs_get(void *data, u64 *val)
  57 {
  58         struct mt7615_dev *dev = data;
  59
  60         *val = dev->phy.scs_en;
  61
  62         return 0;
  63 }
  64
  65 DEFINE_DEBUGFS_ATTRIBUTE(fops_scs, mt7615_scs_get,
  66                          mt7615_scs_set, "%lld\n");
  67
  68 static int
  69 mt7615_pm_set(void *data, u64 val)
  70 {
  71         struct mt7615_dev *dev = data;
  72         struct mt76_connac_pm *pm = &dev->pm;
  73         int ret = 0;
  74
  75         if (!mt7615_wait_for_mcu_init(dev))
  76                 return 0;
  77
  78         if (!mt7615_firmware_offload(dev) || !mt76_is_mmio(&dev->mt76))
  79                 return -EOPNOTSUPP;
  80
  81         if (val == pm->enable)
  82                 return 0;
  83
  84         mt7615_mutex_acquire(dev);
  85
  86         if (dev->phy.n_beacon_vif) {
  87                 ret = -EBUSY;
  88                 goto out;
  89         }
  90
  91         if (!pm->enable) {
  92                 pm->stats.last_wake_event = jiffies;
  93                 pm->stats.last_doze_event = jiffies;
  94         }
  95         pm->enable = val;
  96 out:
  97         mt7615_mutex_release(dev);
  98
  99         return ret;
 100 }
 101
 102 static int
 103 mt7615_pm_get(void *data, u64 *val)
 104 {
 105         struct mt7615_dev *dev = data;
 106
 107         *val = dev->pm.enable;
 108
 109         return 0;
 110 }
 111
 112 DEFINE_DEBUGFS_ATTRIBUTE(fops_pm, mt7615_pm_get, mt7615_pm_set, "%lld\n");
 113
 114 static int
 115 mt7615_pm_stats(struct seq_file *s, void *data)
 116 {
 117         struct mt7615_dev *dev = dev_get_drvdata(s->private);
 118         struct mt76_connac_pm *pm = &dev->pm;
 119         unsigned long awake_time = pm->stats.awake_time;
 120         unsigned long doze_time = pm->stats.doze_time;
 121
 122         if (!test_bit(MT76_STATE_PM, &dev->mphy.state))
 123                 awake_time += jiffies - pm->stats.last_wake_event;
 124         else
 125                 doze_time += jiffies - pm->stats.last_doze_event;
 126
 127         seq_printf(s, "awake time: %14u\ndoze time: %15u\n",
 128                    jiffies_to_msecs(awake_time),
 129                    jiffies_to_msecs(doze_time));
 130
 131         return 0;
 132 }
 133
 134 static int
 135 mt7615_pm_idle_timeout_set(void *data, u64 val)
 136 {
 137         struct mt7615_dev *dev = data;
 138
 139         dev->pm.idle_timeout = msecs_to_jiffies(val);
 140
 141         return 0;
 142 }
 143
 144 static int
 145 mt7615_pm_idle_timeout_get(void *data, u64 *val)
 146 {
 147         struct mt7615_dev *dev = data;
 148
 149         *val = jiffies_to_msecs(dev->pm.idle_timeout);
 150
 151         return 0;
 152 }
 153
 154 DEFINE_DEBUGFS_ATTRIBUTE(fops_pm_idle_timeout, mt7615_pm_idle_timeout_get,
 155                          mt7615_pm_idle_timeout_set, "%lld\n");
 156
 157 static int
 158 mt7615_dbdc_set(void *data, u64 val)
 159 {
 160         struct mt7615_dev *dev = data;
 161
 162         if (!mt7615_wait_for_mcu_init(dev))
 163                 return 0;
 164
 165         if (val)
 166                 mt7615_register_ext_phy(dev);
 167         else
 168                 mt7615_unregister_ext_phy(dev);
 169
 170         return 0;
 171 }
 172
 173 static int
 174 mt7615_dbdc_get(void *data, u64 *val)
 175 {
 176         struct mt7615_dev *dev = data;
 177
 178         *val = !!mt7615_ext_phy(dev);
 179
 180         return 0;
 181 }
 182
 183 DEFINE_DEBUGFS_ATTRIBUTE(fops_dbdc, mt7615_dbdc_get,
 184                          mt7615_dbdc_set, "%lld\n");
 185
 186 static int
 187 mt7615_fw_debug_set(void *data, u64 val)
 188 {
 189         struct mt7615_dev *dev = data;
 190
 191         if (!mt7615_wait_for_mcu_init(dev))
 192                 return 0;
 193
 194         dev->fw_debug = val;
 195
 196         mt7615_mutex_acquire(dev);
 197         mt7615_mcu_fw_log_2_host(dev, dev->fw_debug ? 2 : 0);
 198         mt7615_mutex_release(dev);
 199
 200         return 0;
 201 }
 202
 203 static int
 204 mt7615_fw_debug_get(void *data, u64 *val)
 205 {
 206         struct mt7615_dev *dev = data;
 207
 208         *val = dev->fw_debug;
 209
 210         return 0;
 211 }
 212
 213 DEFINE_DEBUGFS_ATTRIBUTE(fops_fw_debug, mt7615_fw_debug_get,
 214                          mt7615_fw_debug_set, "%lld\n");
 215
 216 static int
 217 mt7615_reset_test_set(void *data, u64 val)
 218 {
 219         struct mt7615_dev *dev = data;
 220         struct sk_buff *skb;
 221
 222         if (!mt7615_wait_for_mcu_init(dev))
 223                 return 0;
 224
 225         skb = alloc_skb(1, GFP_KERNEL);
 226         if (!skb)
 227                 return -ENOMEM;
 228
 229         skb_put(skb, 1);
 230
 231         mt7615_mutex_acquire(dev);
 232         mt76_tx_queue_skb_raw(dev, dev->mphy.q_tx[0], skb, 0);
 233         mt7615_mutex_release(dev);
 234
 235         return 0;
 236 }
 237
 238 DEFINE_DEBUGFS_ATTRIBUTE(fops_reset_test, NULL,
 239                          mt7615_reset_test_set, "%lld\n");
 240
 241 static void
 242 mt7615_ampdu_stat_read_phy(struct mt7615_phy *phy,
 243                            struct seq_file *file)
 244 {
 245         struct mt7615_dev *dev = file->private;
 246         u32 reg = is_mt7663(&dev->mt76) ? MT_MIB_ARNG(0) : MT_AGG_ASRCR0;
 247         bool ext_phy = phy != &dev->phy;
 248         int bound[7], i, range;
 249
 250         if (!phy)
 251                 return;
 252
 253         range = mt76_rr(dev, reg);
 254         for (i = 0; i < 4; i++)
 255                 bound[i] = MT_AGG_ASRCR_RANGE(range, i) + 1;
 256
 257         range = mt76_rr(dev, reg + 4);
 258         for (i = 0; i < 3; i++)
 259                 bound[i + 4] = MT_AGG_ASRCR_RANGE(range, i) + 1;
 260
 261         seq_printf(file, "\nPhy %d\n", ext_phy);
 262
 263         seq_printf(file, "Length: %8d | ", bound[0]);
 264         for (i = 0; i < ARRAY_SIZE(bound) - 1; i++)
 265                 seq_printf(file, "%3d -%3d | ",
 266                            bound[i], bound[i + 1]);
 267         seq_puts(file, "\nCount:  ");
 268
 269         range = ext_phy ? ARRAY_SIZE(dev->mt76.aggr_stats) / 2 : 0;
 270         for (i = 0; i < ARRAY_SIZE(bound); i++)
 271                 seq_printf(file, "%8d | ", dev->mt76.aggr_stats[i + range]);
 272         seq_puts(file, "\n");
 273
 274         seq_printf(file, "BA miss count: %d\n", phy->mib.ba_miss_cnt);
 275         seq_printf(file, "PER: %ld.%1ld%%\n",
 276                    phy->mib.aggr_per / 10, phy->mib.aggr_per % 10);
 277 }
 278
 279 static int
 280 mt7615_ampdu_stat_show(struct seq_file *file, void *data)
 281 {
 282         struct mt7615_dev *dev = file->private;
 283
 284         mt7615_mutex_acquire(dev);
 285
 286         mt7615_ampdu_stat_read_phy(&dev->phy, file);
 287         mt7615_ampdu_stat_read_phy(mt7615_ext_phy(dev), file);
 288
 289         mt7615_mutex_release(dev);
 290
 291         return 0;
 292 }
 293
 294 DEFINE_SHOW_ATTRIBUTE(mt7615_ampdu_stat);
 295
 296 static void
 297 mt7615_radio_read_phy(struct mt7615_phy *phy, struct seq_file *s)
 298 {
 299         struct mt7615_dev *dev = dev_get_drvdata(s->private);
 300         bool ext_phy = phy != &dev->phy;
 301
 302         if (!phy)
 303                 return;
 304
 305         seq_printf(s, "Radio %d sensitivity: ofdm=%d cck=%d\n", ext_phy,
 306                    phy->ofdm_sensitivity, phy->cck_sensitivity);
 307         seq_printf(s, "Radio %d false CCA: ofdm=%d cck=%d\n", ext_phy,
 308                    phy->false_cca_ofdm, phy->false_cca_cck);
 309 }
 310
 311 static int
 312 mt7615_radio_read(struct seq_file *s, void *data)
 313 {
 314         struct mt7615_dev *dev = dev_get_drvdata(s->private);
 315
 316         mt7615_radio_read_phy(&dev->phy, s);
 317         mt7615_radio_read_phy(mt7615_ext_phy(dev), s);
 318
 319         return 0;
 320 }
 321
 322 static int mt7615_read_temperature(struct seq_file *s, void *data)
 323 {
 324         struct mt7615_dev *dev = dev_get_drvdata(s->private);
 325         int temp;
 326
 327         if (!mt7615_wait_for_mcu_init(dev))
 328                 return 0;
 329
 330         /* cpu */
 331         mt7615_mutex_acquire(dev);
 332         temp = mt7615_mcu_get_temperature(dev, 0);
 333         mt7615_mutex_release(dev);
 334
 335         seq_printf(s, "Temperature: %d\n", temp);
 336
 337         return 0;
 338 }
 339
 340 static int
 341 mt7615_queues_acq(struct seq_file *s, void *data)
 342 {
 343         struct mt7615_dev *dev = dev_get_drvdata(s->private);
 344         int i;
 345
 346         mt7615_mutex_acquire(dev);
 347
 348         for (i = 0; i < 16; i++) {
 349                 int j, wmm_idx = i % MT7615_MAX_WMM_SETS;
 350                 int acs = i / MT7615_MAX_WMM_SETS;
 351                 u32 ctrl, val, qlen = 0;
 352
 353                 val = mt76_rr(dev, MT_PLE_AC_QEMPTY(acs, wmm_idx));
 354                 ctrl = BIT(31) | BIT(15) | (acs << 8);
 355
 356                 for (j = 0; j < 32; j++) {
 357                         if (val & BIT(j))
 358                                 continue;
 359
 360                         mt76_wr(dev, MT_PLE_FL_Q0_CTRL,
 361                                 ctrl | (j + (wmm_idx << 5)));
 362                         qlen += mt76_get_field(dev, MT_PLE_FL_Q3_CTRL,
 363                                                GENMASK(11, 0));
 364                 }
 365                 seq_printf(s, "AC%d%d: queued=%d\n", wmm_idx, acs, qlen);
 366         }
 367
 368         mt7615_mutex_release(dev);
 369
 370         return 0;
 371 }
 372
 373 static int
 374 mt7615_queues_read(struct seq_file *s, void *data)
 375 {
 376         struct mt7615_dev *dev = dev_get_drvdata(s->private);
 377         struct {
 378                 struct mt76_queue *q;
 379                 char *queue;
 380         } queue_map[] = {
 381                 { dev->mphy.q_tx[MT_TXQ_BE], "PDMA0" },
 382                 { dev->mt76.q_mcu[MT_MCUQ_WM], "MCUQ" },
 383                 { dev->mt76.q_mcu[MT_MCUQ_FWDL], "MCUFWQ" },
 384         };
 385         int i;
 386
 387         for (i = 0; i < ARRAY_SIZE(queue_map); i++) {
 388                 struct mt76_queue *q = queue_map[i].q;
 389
 390                 seq_printf(s,
 391                            "%s: queued=%d head=%d tail=%d\n",
 392                            queue_map[i].queue, q->queued, q->head,
 393                            q->tail);
 394         }
 395
 396         return 0;
 397 }
 398
 399 static int
 400 mt7615_rf_reg_set(void *data, u64 val)
 401 {
 402         struct mt7615_dev *dev = data;
 403
 404         mt7615_rf_wr(dev, dev->debugfs_rf_wf, dev->debugfs_rf_reg, val);
 405
 406         return 0;
 407 }
 408
 409 static int
 410 mt7615_rf_reg_get(void *data, u64 *val)
 411 {
 412         struct mt7615_dev *dev = data;
 413
 414         *val = mt7615_rf_rr(dev, dev->debugfs_rf_wf, dev->debugfs_rf_reg);
 415
 416         return 0;
 417 }
 418
 419 DEFINE_DEBUGFS_ATTRIBUTE(fops_rf_reg, mt7615_rf_reg_get, mt7615_rf_reg_set,
 420                          "0x%08llx\n");
 421
 422 static ssize_t
 423 mt7615_ext_mac_addr_read(struct file *file, char __user *userbuf,
 424                          size_t count, loff_t *ppos)
 425 {
 426         struct mt7615_dev *dev = file->private_data;
 427         char buf[32 * ((ETH_ALEN * 3) + 4) + 1];
 428         u8 addr[ETH_ALEN];
 429         int ofs = 0;
 430         int i;
 431
 432         for (i = 0; i < 32; i++) {
 433                 if (!(dev->muar_mask & BIT(i)))
 434                         continue;
 435
 436                 mt76_wr(dev, MT_WF_RMAC_MAR1,
 437                         FIELD_PREP(MT_WF_RMAC_MAR1_IDX, i * 2) |
 438                         MT_WF_RMAC_MAR1_START);
 439                 put_unaligned_le32(mt76_rr(dev, MT_WF_RMAC_MAR0), addr);
 440                 put_unaligned_le16((mt76_rr(dev, MT_WF_RMAC_MAR1) &
 441                                     MT_WF_RMAC_MAR1_ADDR), addr + 4);
 442                 ofs += snprintf(buf + ofs, sizeof(buf) - ofs, "%d=%pM\n", i, addr);
 443         }
 444
 445         return simple_read_from_buffer(userbuf, count, ppos, buf, ofs);
 446 }
 447
 448 static ssize_t
 449 mt7615_ext_mac_addr_write(struct file *file, const char __user *userbuf,
 450                           size_t count, loff_t *ppos)
 451 {
 452         struct mt7615_dev *dev = file->private_data;
 453         unsigned long idx = 0;
 454         u8 addr[ETH_ALEN];
 455         char buf[32];
 456         char *p;
 457
 458         if (count > sizeof(buf))
 459                 return -EINVAL;
 460
 461         if (copy_from_user(buf, userbuf, count))
 462                 return -EFAULT;
 463
 464         buf[sizeof(buf) - 1] = '\0';
 465
 466         p = strchr(buf, '=');
 467         if (p) {
 468                 *p = 0;
 469                 p++;
 470
 471                 if (kstrtoul(buf, 0, &idx) || idx > 31)
 472                         return -EINVAL;
 473         } else {
 474                 idx = 0;
 475                 p = buf;
 476         }
 477
 478         if (!mac_pton(p, addr))
 479                 return -EINVAL;
 480
 481         if (is_valid_ether_addr(addr)) {
 482                 dev->muar_mask |= BIT(idx);
 483         } else {
 484                 memset(addr, 0, sizeof(addr));
 485                 dev->muar_mask &= ~BIT(idx);
 486         }
 487
 488         mt76_rmw_field(dev, MT_WF_RMAC_MORE(0), MT_WF_RMAC_MORE_MUAR_MODE, 1);
 489         mt76_wr(dev, MT_WF_RMAC_MAR0, get_unaligned_le32(addr));
 490         mt76_wr(dev, MT_WF_RMAC_MAR1,
 491                 get_unaligned_le16(addr + 4) |
 492                 FIELD_PREP(MT_WF_RMAC_MAR1_IDX, idx * 2) |
 493                 MT_WF_RMAC_MAR1_START |
 494                 MT_WF_RMAC_MAR1_WRITE);
 495
 496         mt76_rmw_field(dev, MT_WF_RMAC_MORE(0), MT_WF_RMAC_MORE_MUAR_MODE, !!dev->muar_mask);
 497
 498         return count;
 499 }
 500
 501 static const struct file_operations fops_ext_mac_addr = {
 502         .open = simple_open,
 503         .llseek = generic_file_llseek,
 504         .read = mt7615_ext_mac_addr_read,
 505         .write = mt7615_ext_mac_addr_write,
 506         .owner = THIS_MODULE,
 507 };
 508
 509 static int
 510 mt7663s_sched_quota_read(struct seq_file *s, void *data)
 511 {
 512         struct mt7615_dev *dev = dev_get_drvdata(s->private);
 513         struct mt76_sdio *sdio = &dev->mt76.sdio;
 514
 515         seq_printf(s, "pse_data_quota\t%d\n", sdio->sched.pse_data_quota);
 516         seq_printf(s, "ple_data_quota\t%d\n", sdio->sched.ple_data_quota);
 517         seq_printf(s, "pse_mcu_quota\t%d\n", sdio->sched.pse_mcu_quota);
 518         seq_printf(s, "sched_deficit\t%d\n", sdio->sched.deficit);
 519
 520         return 0;
 521 }
 522
 523 int mt7615_init_debugfs(struct mt7615_dev *dev)
 524 {
 525         struct dentry *dir;
 526
 527         dir = mt76_register_debugfs(&dev->mt76);
 528         if (!dir)
 529                 return -ENOMEM;
 530
 531         if (is_mt7615(&dev->mt76))
 532                 debugfs_create_devm_seqfile(dev->mt76.dev, "xmit-queues", dir,
 533                                             mt7615_queues_read);
 534         else
 535                 debugfs_create_devm_seqfile(dev->mt76.dev, "xmit-queues", dir,
 536                                             mt76_queues_read);
 537         debugfs_create_devm_seqfile(dev->mt76.dev, "acq", dir,
 538                                     mt7615_queues_acq);
 539         debugfs_create_file("ampdu_stat", 0400, dir, dev, &mt7615_ampdu_stat_fops);
 540         debugfs_create_file("scs", 0600, dir, dev, &fops_scs);
 541         debugfs_create_file("dbdc", 0600, dir, dev, &fops_dbdc);
 542         debugfs_create_file("fw_debug", 0600, dir, dev, &fops_fw_debug);
 543         debugfs_create_file("runtime-pm", 0600, dir, dev, &fops_pm);
 544         debugfs_create_file("idle-timeout", 0600, dir, dev,
 545                             &fops_pm_idle_timeout);
 546         debugfs_create_devm_seqfile(dev->mt76.dev, "runtime_pm_stats", dir,
 547                                     mt7615_pm_stats);
 548         debugfs_create_devm_seqfile(dev->mt76.dev, "radio", dir,
 549                                     mt7615_radio_read);
 550
 551         if (is_mt7615(&dev->mt76)) {
 552                 debugfs_create_u32("dfs_hw_pattern", 0400, dir,
 553                                    &dev->hw_pattern);
 554                 /* test pattern knobs */
 555                 debugfs_create_u8("pattern_len", 0600, dir,
 556                                   &dev->radar_pattern.n_pulses);
 557                 debugfs_create_u32("pulse_period", 0600, dir,
 558                                    &dev->radar_pattern.period);
 559                 debugfs_create_u16("pulse_width", 0600, dir,
 560                                    &dev->radar_pattern.width);
 561                 debugfs_create_u16("pulse_power", 0600, dir,
 562                                    &dev->radar_pattern.power);
 563                 debugfs_create_file("radar_trigger", 0200, dir, dev,
 564                                     &fops_radar_pattern);
 565         }
 566
 567         debugfs_create_file("reset_test", 0200, dir, dev,
 568                             &fops_reset_test);
 569         debugfs_create_devm_seqfile(dev->mt76.dev, "temperature", dir,
 570                                     mt7615_read_temperature);
 571         debugfs_create_file("ext_mac_addr", 0600, dir, dev, &fops_ext_mac_addr);
 572
 573         debugfs_create_u32("rf_wfidx", 0600, dir, &dev->debugfs_rf_wf);
 574         debugfs_create_u32("rf_regidx", 0600, dir, &dev->debugfs_rf_reg);
 575         debugfs_create_file_unsafe("rf_regval", 0600, dir, dev,
 576                                    &fops_rf_reg);
 577         if (is_mt7663(&dev->mt76))
 578                 debugfs_create_file("chip_config", 0600, dir, dev,
 579                                     &fops_config);
 580         if (mt76_is_sdio(&dev->mt76))
 581                 debugfs_create_devm_seqfile(dev->mt76.dev, "sched-quota", dir,
 582                                             mt7663s_sched_quota_read);
 583
 584         return 0;
 585 }
 586 EXPORT_SYMBOL_GPL(mt7615_init_debugfs);