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