mirror of
https://github.com/outbackdingo/mt76.git
synced 2026-10-24 13:26:48 +00:00
Lorenzo BianconiandFelix Fietkau
633ae5961d
In order to reduce cpu cycles, enable hw beacon filter by default if the device is running offload fw with sta only interfaces. Disable runtime pm for multi-vif scenario. Signed-off-by: Lorenzo Bianconi <[email protected]> Signed-off-by: Felix Fietkau <[email protected]>
520 lines
11 KiB
C
520 lines
11 KiB
C
// SPDX-License-Identifier: ISC
|
|
|
|
#include "mt7615.h"
|
|
|
|
static int
|
|
mt7615_radar_pattern_set(void *data, u64 val)
|
|
{
|
|
struct mt7615_dev *dev = data;
|
|
int err;
|
|
|
|
if (!mt7615_wait_for_mcu_init(dev))
|
|
return 0;
|
|
|
|
mt7615_mutex_acquire(dev);
|
|
err = mt7615_mcu_rdd_send_pattern(dev);
|
|
mt7615_mutex_release(dev);
|
|
|
|
return err;
|
|
}
|
|
|
|
DEFINE_DEBUGFS_ATTRIBUTE(fops_radar_pattern, NULL,
|
|
mt7615_radar_pattern_set, "%lld\n");
|
|
|
|
static int
|
|
mt7615_scs_set(void *data, u64 val)
|
|
{
|
|
struct mt7615_dev *dev = data;
|
|
struct mt7615_phy *ext_phy;
|
|
|
|
if (!mt7615_wait_for_mcu_init(dev))
|
|
return 0;
|
|
|
|
mt7615_mac_set_scs(&dev->phy, val);
|
|
ext_phy = mt7615_ext_phy(dev);
|
|
if (ext_phy)
|
|
mt7615_mac_set_scs(ext_phy, val);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
mt7615_scs_get(void *data, u64 *val)
|
|
{
|
|
struct mt7615_dev *dev = data;
|
|
|
|
*val = dev->phy.scs_en;
|
|
|
|
return 0;
|
|
}
|
|
|
|
DEFINE_DEBUGFS_ATTRIBUTE(fops_scs, mt7615_scs_get,
|
|
mt7615_scs_set, "%lld\n");
|
|
|
|
static int
|
|
mt7615_pm_set(void *data, u64 val)
|
|
{
|
|
struct mt7615_dev *dev = data;
|
|
int ret = 0;
|
|
|
|
if (!mt7615_wait_for_mcu_init(dev))
|
|
return 0;
|
|
|
|
if (!mt7615_firmware_offload(dev) || !mt76_is_mmio(&dev->mt76))
|
|
return -EOPNOTSUPP;
|
|
|
|
mt7615_mutex_acquire(dev);
|
|
|
|
if (dev->phy.n_beacon_vif) {
|
|
ret = -EBUSY;
|
|
goto out;
|
|
}
|
|
|
|
dev->pm.enable = val;
|
|
out:
|
|
mt7615_mutex_release(dev);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
mt7615_pm_get(void *data, u64 *val)
|
|
{
|
|
struct mt7615_dev *dev = data;
|
|
|
|
*val = dev->pm.enable;
|
|
|
|
return 0;
|
|
}
|
|
|
|
DEFINE_DEBUGFS_ATTRIBUTE(fops_pm, mt7615_pm_get, mt7615_pm_set, "%lld\n");
|
|
|
|
static int
|
|
mt7615_pm_idle_timeout_set(void *data, u64 val)
|
|
{
|
|
struct mt7615_dev *dev = data;
|
|
|
|
dev->pm.idle_timeout = msecs_to_jiffies(val);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
mt7615_pm_idle_timeout_get(void *data, u64 *val)
|
|
{
|
|
struct mt7615_dev *dev = data;
|
|
|
|
*val = jiffies_to_msecs(dev->pm.idle_timeout);
|
|
|
|
return 0;
|
|
}
|
|
|
|
DEFINE_DEBUGFS_ATTRIBUTE(fops_pm_idle_timeout, mt7615_pm_idle_timeout_get,
|
|
mt7615_pm_idle_timeout_set, "%lld\n");
|
|
|
|
static int
|
|
mt7615_dbdc_set(void *data, u64 val)
|
|
{
|
|
struct mt7615_dev *dev = data;
|
|
|
|
if (!mt7615_wait_for_mcu_init(dev))
|
|
return 0;
|
|
|
|
if (val)
|
|
mt7615_register_ext_phy(dev);
|
|
else
|
|
mt7615_unregister_ext_phy(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
mt7615_dbdc_get(void *data, u64 *val)
|
|
{
|
|
struct mt7615_dev *dev = data;
|
|
|
|
*val = !!mt7615_ext_phy(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
DEFINE_DEBUGFS_ATTRIBUTE(fops_dbdc, mt7615_dbdc_get,
|
|
mt7615_dbdc_set, "%lld\n");
|
|
|
|
static int
|
|
mt7615_fw_debug_set(void *data, u64 val)
|
|
{
|
|
struct mt7615_dev *dev = data;
|
|
|
|
if (!mt7615_wait_for_mcu_init(dev))
|
|
return 0;
|
|
|
|
dev->fw_debug = val;
|
|
|
|
mt7615_mutex_acquire(dev);
|
|
mt7615_mcu_fw_log_2_host(dev, dev->fw_debug ? 2 : 0);
|
|
mt7615_mutex_release(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
mt7615_fw_debug_get(void *data, u64 *val)
|
|
{
|
|
struct mt7615_dev *dev = data;
|
|
|
|
*val = dev->fw_debug;
|
|
|
|
return 0;
|
|
}
|
|
|
|
DEFINE_DEBUGFS_ATTRIBUTE(fops_fw_debug, mt7615_fw_debug_get,
|
|
mt7615_fw_debug_set, "%lld\n");
|
|
|
|
static int
|
|
mt7615_reset_test_set(void *data, u64 val)
|
|
{
|
|
struct mt7615_dev *dev = data;
|
|
struct sk_buff *skb;
|
|
|
|
if (!mt7615_wait_for_mcu_init(dev))
|
|
return 0;
|
|
|
|
skb = alloc_skb(1, GFP_KERNEL);
|
|
if (!skb)
|
|
return -ENOMEM;
|
|
|
|
skb_put(skb, 1);
|
|
|
|
mt7615_mutex_acquire(dev);
|
|
mt76_tx_queue_skb_raw(dev, 0, skb, 0);
|
|
mt7615_mutex_release(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
DEFINE_DEBUGFS_ATTRIBUTE(fops_reset_test, NULL,
|
|
mt7615_reset_test_set, "%lld\n");
|
|
|
|
static void
|
|
mt7615_ampdu_stat_read_phy(struct mt7615_phy *phy,
|
|
struct seq_file *file)
|
|
{
|
|
struct mt7615_dev *dev = file->private;
|
|
u32 reg = is_mt7663(&dev->mt76) ? MT_MIB_ARNG(0) : MT_AGG_ASRCR0;
|
|
bool ext_phy = phy != &dev->phy;
|
|
int bound[7], i, range;
|
|
|
|
if (!phy)
|
|
return;
|
|
|
|
range = mt76_rr(dev, reg);
|
|
for (i = 0; i < 4; i++)
|
|
bound[i] = MT_AGG_ASRCR_RANGE(range, i) + 1;
|
|
|
|
range = mt76_rr(dev, reg + 4);
|
|
for (i = 0; i < 3; i++)
|
|
bound[i + 4] = MT_AGG_ASRCR_RANGE(range, i) + 1;
|
|
|
|
seq_printf(file, "\nPhy %d\n", ext_phy);
|
|
|
|
seq_printf(file, "Length: %8d | ", bound[0]);
|
|
for (i = 0; i < ARRAY_SIZE(bound) - 1; i++)
|
|
seq_printf(file, "%3d -%3d | ",
|
|
bound[i], bound[i + 1]);
|
|
seq_puts(file, "\nCount: ");
|
|
|
|
range = ext_phy ? ARRAY_SIZE(dev->mt76.aggr_stats) / 2 : 0;
|
|
for (i = 0; i < ARRAY_SIZE(bound); i++)
|
|
seq_printf(file, "%8d | ", dev->mt76.aggr_stats[i + range]);
|
|
seq_puts(file, "\n");
|
|
|
|
seq_printf(file, "BA miss count: %d\n", phy->mib.ba_miss_cnt);
|
|
seq_printf(file, "PER: %ld.%1ld%%\n",
|
|
phy->mib.aggr_per / 10, phy->mib.aggr_per % 10);
|
|
}
|
|
|
|
static int
|
|
mt7615_ampdu_stat_show(struct seq_file *file, void *data)
|
|
{
|
|
struct mt7615_dev *dev = file->private;
|
|
|
|
mt7615_mutex_acquire(dev);
|
|
|
|
mt7615_ampdu_stat_read_phy(&dev->phy, file);
|
|
mt7615_ampdu_stat_read_phy(mt7615_ext_phy(dev), file);
|
|
|
|
mt7615_mutex_release(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
DEFINE_SHOW_ATTRIBUTE(mt7615_ampdu_stat);
|
|
|
|
static void
|
|
mt7615_radio_read_phy(struct mt7615_phy *phy, struct seq_file *s)
|
|
{
|
|
struct mt7615_dev *dev = dev_get_drvdata(s->private);
|
|
bool ext_phy = phy != &dev->phy;
|
|
|
|
if (!phy)
|
|
return;
|
|
|
|
seq_printf(s, "Radio %d sensitivity: ofdm=%d cck=%d\n", ext_phy,
|
|
phy->ofdm_sensitivity, phy->cck_sensitivity);
|
|
seq_printf(s, "Radio %d false CCA: ofdm=%d cck=%d\n", ext_phy,
|
|
phy->false_cca_ofdm, phy->false_cca_cck);
|
|
}
|
|
|
|
static int
|
|
mt7615_radio_read(struct seq_file *s, void *data)
|
|
{
|
|
struct mt7615_dev *dev = dev_get_drvdata(s->private);
|
|
|
|
mt7615_radio_read_phy(&dev->phy, s);
|
|
mt7615_radio_read_phy(mt7615_ext_phy(dev), s);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mt7615_read_temperature(struct seq_file *s, void *data)
|
|
{
|
|
struct mt7615_dev *dev = dev_get_drvdata(s->private);
|
|
int temp;
|
|
|
|
if (!mt7615_wait_for_mcu_init(dev))
|
|
return 0;
|
|
|
|
/* cpu */
|
|
mt7615_mutex_acquire(dev);
|
|
temp = mt7615_mcu_get_temperature(dev, 0);
|
|
mt7615_mutex_release(dev);
|
|
|
|
seq_printf(s, "Temperature: %d\n", temp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
mt7615_queues_acq(struct seq_file *s, void *data)
|
|
{
|
|
struct mt7615_dev *dev = dev_get_drvdata(s->private);
|
|
int i;
|
|
|
|
mt7615_mutex_acquire(dev);
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
int j, wmm_idx = i % MT7615_MAX_WMM_SETS;
|
|
int acs = i / MT7615_MAX_WMM_SETS;
|
|
u32 ctrl, val, qlen = 0;
|
|
|
|
val = mt76_rr(dev, MT_PLE_AC_QEMPTY(acs, wmm_idx));
|
|
ctrl = BIT(31) | BIT(15) | (acs << 8);
|
|
|
|
for (j = 0; j < 32; j++) {
|
|
if (val & BIT(j))
|
|
continue;
|
|
|
|
mt76_wr(dev, MT_PLE_FL_Q0_CTRL,
|
|
ctrl | (j + (wmm_idx << 5)));
|
|
qlen += mt76_get_field(dev, MT_PLE_FL_Q3_CTRL,
|
|
GENMASK(11, 0));
|
|
}
|
|
seq_printf(s, "AC%d%d: queued=%d\n", wmm_idx, acs, qlen);
|
|
}
|
|
|
|
mt7615_mutex_release(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
mt7615_queues_read(struct seq_file *s, void *data)
|
|
{
|
|
struct mt7615_dev *dev = dev_get_drvdata(s->private);
|
|
static const struct {
|
|
char *queue;
|
|
int id;
|
|
} queue_map[] = {
|
|
{ "PDMA0", MT_TXQ_BE },
|
|
{ "MCUQ", MT_TXQ_MCU },
|
|
{ "MCUFWQ", MT_TXQ_FWDL },
|
|
};
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(queue_map); i++) {
|
|
struct mt76_queue *q = dev->mt76.q_tx[queue_map[i].id];
|
|
|
|
if (!q)
|
|
continue;
|
|
|
|
seq_printf(s,
|
|
"%s: queued=%d head=%d tail=%d\n",
|
|
queue_map[i].queue, q->queued, q->head,
|
|
q->tail);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
mt7615_rf_reg_set(void *data, u64 val)
|
|
{
|
|
struct mt7615_dev *dev = data;
|
|
|
|
mt7615_rf_wr(dev, dev->debugfs_rf_wf, dev->debugfs_rf_reg, val);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
mt7615_rf_reg_get(void *data, u64 *val)
|
|
{
|
|
struct mt7615_dev *dev = data;
|
|
|
|
*val = mt7615_rf_rr(dev, dev->debugfs_rf_wf, dev->debugfs_rf_reg);
|
|
|
|
return 0;
|
|
}
|
|
|
|
DEFINE_DEBUGFS_ATTRIBUTE(fops_rf_reg, mt7615_rf_reg_get, mt7615_rf_reg_set,
|
|
"0x%08llx\n");
|
|
|
|
static ssize_t
|
|
mt7615_ext_mac_addr_read(struct file *file, char __user *userbuf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct mt7615_dev *dev = file->private_data;
|
|
char buf[32 * ((ETH_ALEN * 3) + 4) + 1];
|
|
u8 addr[ETH_ALEN];
|
|
int ofs = 0;
|
|
int i;
|
|
|
|
for (i = 0; i < 32; i++) {
|
|
if (!(dev->muar_mask & BIT(i)))
|
|
continue;
|
|
|
|
mt76_wr(dev, MT_WF_RMAC_MAR1,
|
|
FIELD_PREP(MT_WF_RMAC_MAR1_IDX, i * 2) |
|
|
MT_WF_RMAC_MAR1_START);
|
|
put_unaligned_le32(mt76_rr(dev, MT_WF_RMAC_MAR0), addr);
|
|
put_unaligned_le16((mt76_rr(dev, MT_WF_RMAC_MAR1) &
|
|
MT_WF_RMAC_MAR1_ADDR), addr + 4);
|
|
ofs += snprintf(buf + ofs, sizeof(buf) - ofs, "%d=%pM\n", i, addr);
|
|
}
|
|
|
|
return simple_read_from_buffer(userbuf, count, ppos, buf, ofs);
|
|
}
|
|
|
|
static ssize_t
|
|
mt7615_ext_mac_addr_write(struct file *file, const char __user *userbuf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct mt7615_dev *dev = file->private_data;
|
|
unsigned long idx = 0;
|
|
u8 addr[ETH_ALEN];
|
|
char buf[32];
|
|
char *p;
|
|
|
|
if (count > sizeof(buf))
|
|
return -EINVAL;
|
|
|
|
if (copy_from_user(buf, userbuf, count))
|
|
return -EFAULT;
|
|
|
|
buf[sizeof(buf) - 1] = '\0';
|
|
|
|
p = strchr(buf, '=');
|
|
if (p) {
|
|
*p = 0;
|
|
p++;
|
|
|
|
if (kstrtoul(buf, 0, &idx) || idx > 31)
|
|
return -EINVAL;
|
|
} else {
|
|
idx = 0;
|
|
p = buf;
|
|
}
|
|
|
|
if (!mac_pton(p, addr))
|
|
return -EINVAL;
|
|
|
|
if (is_valid_ether_addr(addr)) {
|
|
dev->muar_mask |= BIT(idx);
|
|
} else {
|
|
memset(addr, 0, sizeof(addr));
|
|
dev->muar_mask &= ~BIT(idx);
|
|
}
|
|
|
|
mt76_rmw_field(dev, MT_WF_RMAC_MORE(0), MT_WF_RMAC_MORE_MUAR_MODE, 1);
|
|
mt76_wr(dev, MT_WF_RMAC_MAR0, get_unaligned_le32(addr));
|
|
mt76_wr(dev, MT_WF_RMAC_MAR1,
|
|
get_unaligned_le16(addr + 4) |
|
|
FIELD_PREP(MT_WF_RMAC_MAR1_IDX, idx * 2) |
|
|
MT_WF_RMAC_MAR1_START |
|
|
MT_WF_RMAC_MAR1_WRITE);
|
|
|
|
mt76_rmw_field(dev, MT_WF_RMAC_MORE(0), MT_WF_RMAC_MORE_MUAR_MODE, !!dev->muar_mask);
|
|
|
|
return count;
|
|
}
|
|
|
|
static const struct file_operations fops_ext_mac_addr = {
|
|
.open = simple_open,
|
|
.llseek = generic_file_llseek,
|
|
.read = mt7615_ext_mac_addr_read,
|
|
.write = mt7615_ext_mac_addr_write,
|
|
};
|
|
|
|
int mt7615_init_debugfs(struct mt7615_dev *dev)
|
|
{
|
|
struct dentry *dir;
|
|
|
|
dir = mt76_register_debugfs(&dev->mt76);
|
|
if (!dir)
|
|
return -ENOMEM;
|
|
|
|
if (is_mt7615(&dev->mt76))
|
|
debugfs_create_devm_seqfile(dev->mt76.dev, "xmit-queues", dir,
|
|
mt7615_queues_read);
|
|
else
|
|
debugfs_create_devm_seqfile(dev->mt76.dev, "xmit-queues", dir,
|
|
mt76_queues_read);
|
|
debugfs_create_devm_seqfile(dev->mt76.dev, "acq", dir,
|
|
mt7615_queues_acq);
|
|
debugfs_create_file("ampdu_stat", 0400, dir, dev, &mt7615_ampdu_stat_fops);
|
|
debugfs_create_file("scs", 0600, dir, dev, &fops_scs);
|
|
debugfs_create_file("dbdc", 0600, dir, dev, &fops_dbdc);
|
|
debugfs_create_file("fw_debug", 0600, dir, dev, &fops_fw_debug);
|
|
debugfs_create_file("runtime-pm", 0600, dir, dev, &fops_pm);
|
|
debugfs_create_file("idle-timeout", 0600, dir, dev,
|
|
&fops_pm_idle_timeout);
|
|
debugfs_create_devm_seqfile(dev->mt76.dev, "radio", dir,
|
|
mt7615_radio_read);
|
|
debugfs_create_u32("dfs_hw_pattern", 0400, dir, &dev->hw_pattern);
|
|
/* test pattern knobs */
|
|
debugfs_create_u8("pattern_len", 0600, dir,
|
|
&dev->radar_pattern.n_pulses);
|
|
debugfs_create_u32("pulse_period", 0600, dir,
|
|
&dev->radar_pattern.period);
|
|
debugfs_create_u16("pulse_width", 0600, dir,
|
|
&dev->radar_pattern.width);
|
|
debugfs_create_u16("pulse_power", 0600, dir,
|
|
&dev->radar_pattern.power);
|
|
debugfs_create_file("radar_trigger", 0200, dir, dev,
|
|
&fops_radar_pattern);
|
|
debugfs_create_file("reset_test", 0200, dir, dev,
|
|
&fops_reset_test);
|
|
debugfs_create_devm_seqfile(dev->mt76.dev, "temperature", dir,
|
|
mt7615_read_temperature);
|
|
debugfs_create_file("ext_mac_addr", 0600, dir, dev, &fops_ext_mac_addr);
|
|
|
|
debugfs_create_u32("rf_wfidx", 0600, dir, &dev->debugfs_rf_wf);
|
|
debugfs_create_u32("rf_regidx", 0600, dir, &dev->debugfs_rf_reg);
|
|
debugfs_create_file_unsafe("rf_regval", 0600, dir, dev,
|
|
&fops_rf_reg);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(mt7615_init_debugfs);
|