0001
0002
0003
0004
0005 #include <linux/debugfs.h>
0006 #include <linux/seq_file.h>
0007 #include "main.h"
0008 #include "coex.h"
0009 #include "sec.h"
0010 #include "fw.h"
0011 #include "debug.h"
0012 #include "phy.h"
0013 #include "reg.h"
0014 #include "ps.h"
0015 #include "regd.h"
0016
0017 #ifdef CONFIG_RTW88_DEBUGFS
0018
0019 struct rtw_debugfs_priv {
0020 struct rtw_dev *rtwdev;
0021 int (*cb_read)(struct seq_file *m, void *v);
0022 ssize_t (*cb_write)(struct file *filp, const char __user *buffer,
0023 size_t count, loff_t *loff);
0024 union {
0025 u32 cb_data;
0026 u8 *buf;
0027 struct {
0028 u32 page_offset;
0029 u32 page_num;
0030 } rsvd_page;
0031 struct {
0032 u8 rf_path;
0033 u32 rf_addr;
0034 u32 rf_mask;
0035 };
0036 struct {
0037 u32 addr;
0038 u32 len;
0039 } read_reg;
0040 struct {
0041 u8 bit;
0042 } dm_cap;
0043 };
0044 };
0045
0046 static const char * const rtw_dm_cap_strs[] = {
0047 [RTW_DM_CAP_NA] = "NA",
0048 [RTW_DM_CAP_TXGAPK] = "TXGAPK",
0049 };
0050
0051 static int rtw_debugfs_single_show(struct seq_file *m, void *v)
0052 {
0053 struct rtw_debugfs_priv *debugfs_priv = m->private;
0054
0055 return debugfs_priv->cb_read(m, v);
0056 }
0057
0058 static ssize_t rtw_debugfs_common_write(struct file *filp,
0059 const char __user *buffer,
0060 size_t count, loff_t *loff)
0061 {
0062 struct rtw_debugfs_priv *debugfs_priv = filp->private_data;
0063
0064 return debugfs_priv->cb_write(filp, buffer, count, loff);
0065 }
0066
0067 static ssize_t rtw_debugfs_single_write(struct file *filp,
0068 const char __user *buffer,
0069 size_t count, loff_t *loff)
0070 {
0071 struct seq_file *seqpriv = (struct seq_file *)filp->private_data;
0072 struct rtw_debugfs_priv *debugfs_priv = seqpriv->private;
0073
0074 return debugfs_priv->cb_write(filp, buffer, count, loff);
0075 }
0076
0077 static int rtw_debugfs_single_open_rw(struct inode *inode, struct file *filp)
0078 {
0079 return single_open(filp, rtw_debugfs_single_show, inode->i_private);
0080 }
0081
0082 static int rtw_debugfs_close(struct inode *inode, struct file *filp)
0083 {
0084 return 0;
0085 }
0086
0087 static const struct file_operations file_ops_single_r = {
0088 .owner = THIS_MODULE,
0089 .open = rtw_debugfs_single_open_rw,
0090 .read = seq_read,
0091 .llseek = seq_lseek,
0092 .release = single_release,
0093 };
0094
0095 static const struct file_operations file_ops_single_rw = {
0096 .owner = THIS_MODULE,
0097 .open = rtw_debugfs_single_open_rw,
0098 .release = single_release,
0099 .read = seq_read,
0100 .llseek = seq_lseek,
0101 .write = rtw_debugfs_single_write,
0102 };
0103
0104 static const struct file_operations file_ops_common_write = {
0105 .owner = THIS_MODULE,
0106 .write = rtw_debugfs_common_write,
0107 .open = simple_open,
0108 .release = rtw_debugfs_close,
0109 };
0110
0111 static int rtw_debugfs_get_read_reg(struct seq_file *m, void *v)
0112 {
0113 struct rtw_debugfs_priv *debugfs_priv = m->private;
0114 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0115 u32 val, len, addr;
0116
0117 len = debugfs_priv->read_reg.len;
0118 addr = debugfs_priv->read_reg.addr;
0119 switch (len) {
0120 case 1:
0121 val = rtw_read8(rtwdev, addr);
0122 seq_printf(m, "reg 0x%03x: 0x%02x\n", addr, val);
0123 break;
0124 case 2:
0125 val = rtw_read16(rtwdev, addr);
0126 seq_printf(m, "reg 0x%03x: 0x%04x\n", addr, val);
0127 break;
0128 case 4:
0129 val = rtw_read32(rtwdev, addr);
0130 seq_printf(m, "reg 0x%03x: 0x%08x\n", addr, val);
0131 break;
0132 }
0133 return 0;
0134 }
0135
0136 static int rtw_debugfs_get_rf_read(struct seq_file *m, void *v)
0137 {
0138 struct rtw_debugfs_priv *debugfs_priv = m->private;
0139 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0140 u32 val, addr, mask;
0141 u8 path;
0142
0143 path = debugfs_priv->rf_path;
0144 addr = debugfs_priv->rf_addr;
0145 mask = debugfs_priv->rf_mask;
0146
0147 val = rtw_read_rf(rtwdev, path, addr, mask);
0148
0149 seq_printf(m, "rf_read path:%d addr:0x%08x mask:0x%08x val=0x%08x\n",
0150 path, addr, mask, val);
0151
0152 return 0;
0153 }
0154
0155 static int rtw_debugfs_get_fix_rate(struct seq_file *m, void *v)
0156 {
0157 struct rtw_debugfs_priv *debugfs_priv = m->private;
0158 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0159 struct rtw_dm_info *dm_info = &rtwdev->dm_info;
0160 u8 fix_rate = dm_info->fix_rate;
0161
0162 if (fix_rate >= DESC_RATE_MAX) {
0163 seq_printf(m, "Fix rate disabled, fix_rate = %u\n", fix_rate);
0164 return 0;
0165 }
0166
0167 seq_printf(m, "Data frames fixed at desc rate %u\n", fix_rate);
0168 return 0;
0169 }
0170
0171 static int rtw_debugfs_copy_from_user(char tmp[], int size,
0172 const char __user *buffer, size_t count,
0173 int num)
0174 {
0175 int tmp_len;
0176
0177 memset(tmp, 0, size);
0178
0179 if (count < num)
0180 return -EFAULT;
0181
0182 tmp_len = (count > size - 1 ? size - 1 : count);
0183
0184 if (!buffer || copy_from_user(tmp, buffer, tmp_len))
0185 return count;
0186
0187 tmp[tmp_len] = '\0';
0188
0189 return 0;
0190 }
0191
0192 static ssize_t rtw_debugfs_set_read_reg(struct file *filp,
0193 const char __user *buffer,
0194 size_t count, loff_t *loff)
0195 {
0196 struct seq_file *seqpriv = (struct seq_file *)filp->private_data;
0197 struct rtw_debugfs_priv *debugfs_priv = seqpriv->private;
0198 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0199 char tmp[32 + 1];
0200 u32 addr, len;
0201 int num;
0202
0203 rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 2);
0204
0205 num = sscanf(tmp, "%x %x", &addr, &len);
0206
0207 if (num != 2)
0208 return count;
0209
0210 if (len != 1 && len != 2 && len != 4) {
0211 rtw_warn(rtwdev, "read reg setting wrong len\n");
0212 return -EINVAL;
0213 }
0214 debugfs_priv->read_reg.addr = addr;
0215 debugfs_priv->read_reg.len = len;
0216
0217 return count;
0218 }
0219
0220 static int rtw_debugfs_get_dump_cam(struct seq_file *m, void *v)
0221 {
0222 struct rtw_debugfs_priv *debugfs_priv = m->private;
0223 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0224 u32 val, command;
0225 u32 hw_key_idx = debugfs_priv->cb_data << RTW_SEC_CAM_ENTRY_SHIFT;
0226 u32 read_cmd = RTW_SEC_CMD_POLLING;
0227 int i;
0228
0229 seq_printf(m, "cam entry%d\n", debugfs_priv->cb_data);
0230 seq_puts(m, "0x0 0x1 0x2 0x3 ");
0231 seq_puts(m, "0x4 0x5\n");
0232 mutex_lock(&rtwdev->mutex);
0233 for (i = 0; i <= 5; i++) {
0234 command = read_cmd | (hw_key_idx + i);
0235 rtw_write32(rtwdev, RTW_SEC_CMD_REG, command);
0236 val = rtw_read32(rtwdev, RTW_SEC_READ_REG);
0237 seq_printf(m, "%8.8x", val);
0238 if (i < 2)
0239 seq_puts(m, " ");
0240 }
0241 seq_puts(m, "\n");
0242 mutex_unlock(&rtwdev->mutex);
0243 return 0;
0244 }
0245
0246 static int rtw_debugfs_get_rsvd_page(struct seq_file *m, void *v)
0247 {
0248 struct rtw_debugfs_priv *debugfs_priv = m->private;
0249 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0250 u8 page_size = rtwdev->chip->page_size;
0251 u32 buf_size = debugfs_priv->rsvd_page.page_num * page_size;
0252 u32 offset = debugfs_priv->rsvd_page.page_offset * page_size;
0253 u8 *buf;
0254 int i;
0255 int ret;
0256
0257 buf = vzalloc(buf_size);
0258 if (!buf)
0259 return -ENOMEM;
0260
0261 ret = rtw_fw_dump_fifo(rtwdev, RTW_FW_FIFO_SEL_RSVD_PAGE, offset,
0262 buf_size, (u32 *)buf);
0263 if (ret) {
0264 rtw_err(rtwdev, "failed to dump rsvd page\n");
0265 vfree(buf);
0266 return ret;
0267 }
0268
0269 for (i = 0 ; i < buf_size ; i += 8) {
0270 if (i % page_size == 0)
0271 seq_printf(m, "PAGE %d\n", (i + offset) / page_size);
0272 seq_printf(m, "%8ph\n", buf + i);
0273 }
0274 vfree(buf);
0275
0276 return 0;
0277 }
0278
0279 static ssize_t rtw_debugfs_set_rsvd_page(struct file *filp,
0280 const char __user *buffer,
0281 size_t count, loff_t *loff)
0282 {
0283 struct seq_file *seqpriv = (struct seq_file *)filp->private_data;
0284 struct rtw_debugfs_priv *debugfs_priv = seqpriv->private;
0285 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0286 char tmp[32 + 1];
0287 u32 offset, page_num;
0288 int num;
0289
0290 rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 2);
0291
0292 num = sscanf(tmp, "%d %d", &offset, &page_num);
0293
0294 if (num != 2) {
0295 rtw_warn(rtwdev, "invalid arguments\n");
0296 return -EINVAL;
0297 }
0298
0299 debugfs_priv->rsvd_page.page_offset = offset;
0300 debugfs_priv->rsvd_page.page_num = page_num;
0301
0302 return count;
0303 }
0304
0305 static ssize_t rtw_debugfs_set_single_input(struct file *filp,
0306 const char __user *buffer,
0307 size_t count, loff_t *loff)
0308 {
0309 struct seq_file *seqpriv = (struct seq_file *)filp->private_data;
0310 struct rtw_debugfs_priv *debugfs_priv = seqpriv->private;
0311 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0312 char tmp[32 + 1];
0313 u32 input;
0314 int num;
0315
0316 rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 1);
0317
0318 num = kstrtoint(tmp, 0, &input);
0319
0320 if (num) {
0321 rtw_warn(rtwdev, "kstrtoint failed\n");
0322 return num;
0323 }
0324
0325 debugfs_priv->cb_data = input;
0326
0327 return count;
0328 }
0329
0330 static ssize_t rtw_debugfs_set_write_reg(struct file *filp,
0331 const char __user *buffer,
0332 size_t count, loff_t *loff)
0333 {
0334 struct rtw_debugfs_priv *debugfs_priv = filp->private_data;
0335 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0336 char tmp[32 + 1];
0337 u32 addr, val, len;
0338 int num;
0339
0340 rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 3);
0341
0342
0343 num = sscanf(tmp, "%x %x %x", &addr, &val, &len);
0344
0345 if (num != 3)
0346 return count;
0347
0348 switch (len) {
0349 case 1:
0350 rtw_dbg(rtwdev, RTW_DBG_DEBUGFS,
0351 "reg write8 0x%03x: 0x%08x\n", addr, val);
0352 rtw_write8(rtwdev, addr, (u8)val);
0353 break;
0354 case 2:
0355 rtw_dbg(rtwdev, RTW_DBG_DEBUGFS,
0356 "reg write16 0x%03x: 0x%08x\n", addr, val);
0357 rtw_write16(rtwdev, addr, (u16)val);
0358 break;
0359 case 4:
0360 rtw_dbg(rtwdev, RTW_DBG_DEBUGFS,
0361 "reg write32 0x%03x: 0x%08x\n", addr, val);
0362 rtw_write32(rtwdev, addr, (u32)val);
0363 break;
0364 default:
0365 rtw_dbg(rtwdev, RTW_DBG_DEBUGFS,
0366 "error write length = %d\n", len);
0367 break;
0368 }
0369
0370 return count;
0371 }
0372
0373 static ssize_t rtw_debugfs_set_h2c(struct file *filp,
0374 const char __user *buffer,
0375 size_t count, loff_t *loff)
0376 {
0377 struct rtw_debugfs_priv *debugfs_priv = filp->private_data;
0378 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0379 char tmp[32 + 1];
0380 u8 param[8];
0381 int num;
0382
0383 rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 3);
0384
0385 num = sscanf(tmp, "%hhx,%hhx,%hhx,%hhx,%hhx,%hhx,%hhx,%hhx",
0386 ¶m[0], ¶m[1], ¶m[2], ¶m[3],
0387 ¶m[4], ¶m[5], ¶m[6], ¶m[7]);
0388 if (num != 8) {
0389 rtw_warn(rtwdev, "invalid H2C command format for debug\n");
0390 return -EINVAL;
0391 }
0392
0393 rtw_fw_h2c_cmd_dbg(rtwdev, param);
0394
0395 return count;
0396 }
0397
0398 static ssize_t rtw_debugfs_set_rf_write(struct file *filp,
0399 const char __user *buffer,
0400 size_t count, loff_t *loff)
0401 {
0402 struct rtw_debugfs_priv *debugfs_priv = filp->private_data;
0403 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0404 char tmp[32 + 1];
0405 u32 path, addr, mask, val;
0406 int num;
0407
0408 rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 4);
0409
0410 num = sscanf(tmp, "%x %x %x %x", &path, &addr, &mask, &val);
0411
0412 if (num != 4) {
0413 rtw_warn(rtwdev, "invalid args, [path] [addr] [mask] [val]\n");
0414 return count;
0415 }
0416
0417 rtw_write_rf(rtwdev, path, addr, mask, val);
0418 rtw_dbg(rtwdev, RTW_DBG_DEBUGFS,
0419 "write_rf path:%d addr:0x%08x mask:0x%08x, val:0x%08x\n",
0420 path, addr, mask, val);
0421
0422 return count;
0423 }
0424
0425 static ssize_t rtw_debugfs_set_rf_read(struct file *filp,
0426 const char __user *buffer,
0427 size_t count, loff_t *loff)
0428 {
0429 struct seq_file *seqpriv = (struct seq_file *)filp->private_data;
0430 struct rtw_debugfs_priv *debugfs_priv = seqpriv->private;
0431 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0432 char tmp[32 + 1];
0433 u32 path, addr, mask;
0434 int num;
0435
0436 rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 3);
0437
0438 num = sscanf(tmp, "%x %x %x", &path, &addr, &mask);
0439
0440 if (num != 3) {
0441 rtw_warn(rtwdev, "invalid args, [path] [addr] [mask] [val]\n");
0442 return count;
0443 }
0444
0445 debugfs_priv->rf_path = path;
0446 debugfs_priv->rf_addr = addr;
0447 debugfs_priv->rf_mask = mask;
0448
0449 return count;
0450 }
0451
0452 static ssize_t rtw_debugfs_set_fix_rate(struct file *filp,
0453 const char __user *buffer,
0454 size_t count, loff_t *loff)
0455 {
0456 struct seq_file *seqpriv = (struct seq_file *)filp->private_data;
0457 struct rtw_debugfs_priv *debugfs_priv = seqpriv->private;
0458 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0459 struct rtw_dm_info *dm_info = &rtwdev->dm_info;
0460 u8 fix_rate;
0461 char tmp[32 + 1];
0462 int ret;
0463
0464 rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 1);
0465
0466 ret = kstrtou8(tmp, 0, &fix_rate);
0467 if (ret) {
0468 rtw_warn(rtwdev, "invalid args, [rate]\n");
0469 return ret;
0470 }
0471
0472 dm_info->fix_rate = fix_rate;
0473
0474 return count;
0475 }
0476
0477 static int rtw_debug_get_mac_page(struct seq_file *m, void *v)
0478 {
0479 struct rtw_debugfs_priv *debugfs_priv = m->private;
0480 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0481 u32 page = debugfs_priv->cb_data;
0482 int i, n;
0483 int max = 0xff;
0484
0485 rtw_read32(rtwdev, debugfs_priv->cb_data);
0486 for (n = 0; n <= max; ) {
0487 seq_printf(m, "\n%8.8x ", n + page);
0488 for (i = 0; i < 4 && n <= max; i++, n += 4)
0489 seq_printf(m, "%8.8x ",
0490 rtw_read32(rtwdev, (page | n)));
0491 }
0492 seq_puts(m, "\n");
0493 return 0;
0494 }
0495
0496 static int rtw_debug_get_bb_page(struct seq_file *m, void *v)
0497 {
0498 struct rtw_debugfs_priv *debugfs_priv = m->private;
0499 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0500 u32 page = debugfs_priv->cb_data;
0501 int i, n;
0502 int max = 0xff;
0503
0504 rtw_read32(rtwdev, debugfs_priv->cb_data);
0505 for (n = 0; n <= max; ) {
0506 seq_printf(m, "\n%8.8x ", n + page);
0507 for (i = 0; i < 4 && n <= max; i++, n += 4)
0508 seq_printf(m, "%8.8x ",
0509 rtw_read32(rtwdev, (page | n)));
0510 }
0511 seq_puts(m, "\n");
0512 return 0;
0513 }
0514
0515 static int rtw_debug_get_rf_dump(struct seq_file *m, void *v)
0516 {
0517 struct rtw_debugfs_priv *debugfs_priv = m->private;
0518 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0519 u32 addr, offset, data;
0520 u8 path;
0521
0522 for (path = 0; path < rtwdev->hal.rf_path_num; path++) {
0523 seq_printf(m, "RF path:%d\n", path);
0524 for (addr = 0; addr < 0x100; addr += 4) {
0525 seq_printf(m, "%8.8x ", addr);
0526 for (offset = 0; offset < 4; offset++) {
0527 data = rtw_read_rf(rtwdev, path, addr + offset,
0528 0xffffffff);
0529 seq_printf(m, "%8.8x ", data);
0530 }
0531 seq_puts(m, "\n");
0532 }
0533 seq_puts(m, "\n");
0534 }
0535
0536 return 0;
0537 }
0538
0539 static void rtw_print_cck_rate_txt(struct seq_file *m, u8 rate)
0540 {
0541 static const char * const
0542 cck_rate[] = {"1M", "2M", "5.5M", "11M"};
0543 u8 idx = rate - DESC_RATE1M;
0544
0545 seq_printf(m, " CCK_%-5s", cck_rate[idx]);
0546 }
0547
0548 static void rtw_print_ofdm_rate_txt(struct seq_file *m, u8 rate)
0549 {
0550 static const char * const
0551 ofdm_rate[] = {"6M", "9M", "12M", "18M", "24M", "36M", "48M", "54M"};
0552 u8 idx = rate - DESC_RATE6M;
0553
0554 seq_printf(m, " OFDM_%-4s", ofdm_rate[idx]);
0555 }
0556
0557 static void rtw_print_ht_rate_txt(struct seq_file *m, u8 rate)
0558 {
0559 u8 mcs_n = rate - DESC_RATEMCS0;
0560
0561 seq_printf(m, " MCS%-6u", mcs_n);
0562 }
0563
0564 static void rtw_print_vht_rate_txt(struct seq_file *m, u8 rate)
0565 {
0566 u8 idx = rate - DESC_RATEVHT1SS_MCS0;
0567 u8 n_ss, mcs_n;
0568
0569
0570 n_ss = 1 + idx / 10;
0571
0572 mcs_n = idx % 10;
0573 seq_printf(m, " VHT%uSMCS%u", n_ss, mcs_n);
0574 }
0575
0576 static void rtw_print_rate(struct seq_file *m, u8 rate)
0577 {
0578 switch (rate) {
0579 case DESC_RATE1M...DESC_RATE11M:
0580 rtw_print_cck_rate_txt(m, rate);
0581 break;
0582 case DESC_RATE6M...DESC_RATE54M:
0583 rtw_print_ofdm_rate_txt(m, rate);
0584 break;
0585 case DESC_RATEMCS0...DESC_RATEMCS15:
0586 rtw_print_ht_rate_txt(m, rate);
0587 break;
0588 case DESC_RATEVHT1SS_MCS0...DESC_RATEVHT2SS_MCS9:
0589 rtw_print_vht_rate_txt(m, rate);
0590 break;
0591 default:
0592 seq_printf(m, " Unknown rate=0x%x\n", rate);
0593 break;
0594 }
0595 }
0596
0597 #define case_REGD(src) \
0598 case RTW_REGD_##src: return #src
0599
0600 static const char *rtw_get_regd_string(u8 regd)
0601 {
0602 switch (regd) {
0603 case_REGD(FCC);
0604 case_REGD(MKK);
0605 case_REGD(ETSI);
0606 case_REGD(IC);
0607 case_REGD(KCC);
0608 case_REGD(ACMA);
0609 case_REGD(CHILE);
0610 case_REGD(UKRAINE);
0611 case_REGD(MEXICO);
0612 case_REGD(CN);
0613 case_REGD(WW);
0614 default:
0615 return "Unknown";
0616 }
0617 }
0618
0619 static int rtw_debugfs_get_tx_pwr_tbl(struct seq_file *m, void *v)
0620 {
0621 struct rtw_debugfs_priv *debugfs_priv = m->private;
0622 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0623 struct rtw_hal *hal = &rtwdev->hal;
0624 u8 path, rate;
0625 struct rtw_power_params pwr_param = {0};
0626 u8 bw = hal->current_band_width;
0627 u8 ch = hal->current_channel;
0628 u8 regd = rtw_regd_get(rtwdev);
0629
0630 seq_printf(m, "channel: %u\n", ch);
0631 seq_printf(m, "bandwidth: %u\n", bw);
0632 seq_printf(m, "regulatory: %s\n", rtw_get_regd_string(regd));
0633 seq_printf(m, "%-4s %-10s %-9s %-9s (%-4s %-4s %-4s) %-4s\n",
0634 "path", "rate", "pwr", "base", "byr", "lmt", "sar", "rem");
0635
0636 mutex_lock(&hal->tx_power_mutex);
0637 for (path = RF_PATH_A; path <= RF_PATH_B; path++) {
0638
0639 if (hal->current_band_type == RTW_BAND_5G)
0640 rate = DESC_RATE6M;
0641 else
0642 rate = DESC_RATE1M;
0643
0644
0645 for (; rate <= DESC_RATEVHT2SS_MCS9; rate++) {
0646
0647 if (rate > DESC_RATEMCS15 &&
0648 rate < DESC_RATEVHT1SS_MCS0)
0649 continue;
0650
0651 rtw_get_tx_power_params(rtwdev, path, rate, bw,
0652 ch, regd, &pwr_param);
0653
0654 seq_printf(m, "%4c ", path + 'A');
0655 rtw_print_rate(m, rate);
0656 seq_printf(m, " %3u(0x%02x) %4u %4d (%4d %4d %4d) %4d\n",
0657 hal->tx_pwr_tbl[path][rate],
0658 hal->tx_pwr_tbl[path][rate],
0659 pwr_param.pwr_base,
0660 min3(pwr_param.pwr_offset,
0661 pwr_param.pwr_limit,
0662 pwr_param.pwr_sar),
0663 pwr_param.pwr_offset, pwr_param.pwr_limit,
0664 pwr_param.pwr_sar,
0665 pwr_param.pwr_remnant);
0666 }
0667 }
0668
0669 mutex_unlock(&hal->tx_power_mutex);
0670
0671 return 0;
0672 }
0673
0674 void rtw_debugfs_get_simple_phy_info(struct seq_file *m)
0675 {
0676 struct rtw_debugfs_priv *debugfs_priv = m->private;
0677 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0678 struct rtw_hal *hal = &rtwdev->hal;
0679 struct rtw_dm_info *dm_info = &rtwdev->dm_info;
0680 struct rtw_traffic_stats *stats = &rtwdev->stats;
0681
0682 seq_printf(m, "%-40s = %ddBm/ %d\n", "RSSI/ STA Channel",
0683 dm_info->rssi[RF_PATH_A] - 100, hal->current_channel);
0684
0685 seq_printf(m, "TP {Tx, Rx} = {%u, %u}Mbps\n",
0686 stats->tx_throughput, stats->rx_throughput);
0687
0688 seq_puts(m, "[Tx Rate] = ");
0689 rtw_print_rate(m, dm_info->tx_rate);
0690 seq_printf(m, "(0x%x)\n", dm_info->tx_rate);
0691
0692 seq_puts(m, "[Rx Rate] = ");
0693 rtw_print_rate(m, dm_info->curr_rx_rate);
0694 seq_printf(m, "(0x%x)\n", dm_info->curr_rx_rate);
0695 }
0696
0697 static int rtw_debugfs_get_phy_info(struct seq_file *m, void *v)
0698 {
0699 struct rtw_debugfs_priv *debugfs_priv = m->private;
0700 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0701 struct rtw_dm_info *dm_info = &rtwdev->dm_info;
0702 struct rtw_traffic_stats *stats = &rtwdev->stats;
0703 struct rtw_pkt_count *last_cnt = &dm_info->last_pkt_count;
0704 struct rtw_efuse *efuse = &rtwdev->efuse;
0705 struct ewma_evm *ewma_evm = dm_info->ewma_evm;
0706 struct ewma_snr *ewma_snr = dm_info->ewma_snr;
0707 u8 ss, rate_id;
0708
0709 seq_puts(m, "==========[Common Info]========\n");
0710 seq_printf(m, "Is link = %c\n", rtw_is_assoc(rtwdev) ? 'Y' : 'N');
0711 seq_printf(m, "Current CH(fc) = %u\n", rtwdev->hal.current_channel);
0712 seq_printf(m, "Current BW = %u\n", rtwdev->hal.current_band_width);
0713 seq_printf(m, "Current IGI = 0x%x\n", dm_info->igi_history[0]);
0714 seq_printf(m, "TP {Tx, Rx} = {%u, %u}Mbps\n",
0715 stats->tx_throughput, stats->rx_throughput);
0716 seq_printf(m, "1SS for TX and RX = %c\n\n", rtwdev->hal.txrx_1ss ?
0717 'Y' : 'N');
0718
0719 seq_puts(m, "==========[Tx Phy Info]========\n");
0720 seq_puts(m, "[Tx Rate] = ");
0721 rtw_print_rate(m, dm_info->tx_rate);
0722 seq_printf(m, "(0x%x)\n\n", dm_info->tx_rate);
0723
0724 seq_puts(m, "==========[Rx Phy Info]========\n");
0725 seq_printf(m, "[Rx Beacon Count] = %u\n", last_cnt->num_bcn_pkt);
0726 seq_puts(m, "[Rx Rate] = ");
0727 rtw_print_rate(m, dm_info->curr_rx_rate);
0728 seq_printf(m, "(0x%x)\n", dm_info->curr_rx_rate);
0729
0730 seq_puts(m, "[Rx Rate Count]:\n");
0731 seq_printf(m, " * CCK = {%u, %u, %u, %u}\n",
0732 last_cnt->num_qry_pkt[DESC_RATE1M],
0733 last_cnt->num_qry_pkt[DESC_RATE2M],
0734 last_cnt->num_qry_pkt[DESC_RATE5_5M],
0735 last_cnt->num_qry_pkt[DESC_RATE11M]);
0736
0737 seq_printf(m, " * OFDM = {%u, %u, %u, %u, %u, %u, %u, %u}\n",
0738 last_cnt->num_qry_pkt[DESC_RATE6M],
0739 last_cnt->num_qry_pkt[DESC_RATE9M],
0740 last_cnt->num_qry_pkt[DESC_RATE12M],
0741 last_cnt->num_qry_pkt[DESC_RATE18M],
0742 last_cnt->num_qry_pkt[DESC_RATE24M],
0743 last_cnt->num_qry_pkt[DESC_RATE36M],
0744 last_cnt->num_qry_pkt[DESC_RATE48M],
0745 last_cnt->num_qry_pkt[DESC_RATE54M]);
0746
0747 for (ss = 0; ss < efuse->hw_cap.nss; ss++) {
0748 rate_id = DESC_RATEMCS0 + ss * 8;
0749 seq_printf(m, " * HT_MCS[%u:%u] = {%u, %u, %u, %u, %u, %u, %u, %u}\n",
0750 ss * 8, ss * 8 + 7,
0751 last_cnt->num_qry_pkt[rate_id],
0752 last_cnt->num_qry_pkt[rate_id + 1],
0753 last_cnt->num_qry_pkt[rate_id + 2],
0754 last_cnt->num_qry_pkt[rate_id + 3],
0755 last_cnt->num_qry_pkt[rate_id + 4],
0756 last_cnt->num_qry_pkt[rate_id + 5],
0757 last_cnt->num_qry_pkt[rate_id + 6],
0758 last_cnt->num_qry_pkt[rate_id + 7]);
0759 }
0760
0761 for (ss = 0; ss < efuse->hw_cap.nss; ss++) {
0762 rate_id = DESC_RATEVHT1SS_MCS0 + ss * 10;
0763 seq_printf(m, " * VHT_MCS-%uss MCS[0:9] = {%u, %u, %u, %u, %u, %u, %u, %u, %u, %u}\n",
0764 ss + 1,
0765 last_cnt->num_qry_pkt[rate_id],
0766 last_cnt->num_qry_pkt[rate_id + 1],
0767 last_cnt->num_qry_pkt[rate_id + 2],
0768 last_cnt->num_qry_pkt[rate_id + 3],
0769 last_cnt->num_qry_pkt[rate_id + 4],
0770 last_cnt->num_qry_pkt[rate_id + 5],
0771 last_cnt->num_qry_pkt[rate_id + 6],
0772 last_cnt->num_qry_pkt[rate_id + 7],
0773 last_cnt->num_qry_pkt[rate_id + 8],
0774 last_cnt->num_qry_pkt[rate_id + 9]);
0775 }
0776
0777 seq_printf(m, "[RSSI(dBm)] = {%d, %d}\n",
0778 dm_info->rssi[RF_PATH_A] - 100,
0779 dm_info->rssi[RF_PATH_B] - 100);
0780 seq_printf(m, "[Rx EVM(dB)] = {-%d, -%d}\n",
0781 dm_info->rx_evm_dbm[RF_PATH_A],
0782 dm_info->rx_evm_dbm[RF_PATH_B]);
0783 seq_printf(m, "[Rx SNR] = {%d, %d}\n",
0784 dm_info->rx_snr[RF_PATH_A],
0785 dm_info->rx_snr[RF_PATH_B]);
0786 seq_printf(m, "[CFO_tail(KHz)] = {%d, %d}\n",
0787 dm_info->cfo_tail[RF_PATH_A],
0788 dm_info->cfo_tail[RF_PATH_B]);
0789
0790 if (dm_info->curr_rx_rate >= DESC_RATE11M) {
0791 seq_puts(m, "[Rx Average Status]:\n");
0792 seq_printf(m, " * OFDM, EVM: {-%d}, SNR: {%d}\n",
0793 (u8)ewma_evm_read(&ewma_evm[RTW_EVM_OFDM]),
0794 (u8)ewma_snr_read(&ewma_snr[RTW_SNR_OFDM_A]));
0795 seq_printf(m, " * 1SS, EVM: {-%d}, SNR: {%d}\n",
0796 (u8)ewma_evm_read(&ewma_evm[RTW_EVM_1SS]),
0797 (u8)ewma_snr_read(&ewma_snr[RTW_SNR_1SS_A]));
0798 seq_printf(m, " * 2SS, EVM: {-%d, -%d}, SNR: {%d, %d}\n",
0799 (u8)ewma_evm_read(&ewma_evm[RTW_EVM_2SS_A]),
0800 (u8)ewma_evm_read(&ewma_evm[RTW_EVM_2SS_B]),
0801 (u8)ewma_snr_read(&ewma_snr[RTW_SNR_2SS_A]),
0802 (u8)ewma_snr_read(&ewma_snr[RTW_SNR_2SS_B]));
0803 }
0804
0805 seq_puts(m, "[Rx Counter]:\n");
0806 seq_printf(m, " * CCA (CCK, OFDM, Total) = (%u, %u, %u)\n",
0807 dm_info->cck_cca_cnt,
0808 dm_info->ofdm_cca_cnt,
0809 dm_info->total_cca_cnt);
0810 seq_printf(m, " * False Alarm (CCK, OFDM, Total) = (%u, %u, %u)\n",
0811 dm_info->cck_fa_cnt,
0812 dm_info->ofdm_fa_cnt,
0813 dm_info->total_fa_cnt);
0814 seq_printf(m, " * CCK cnt (ok, err) = (%u, %u)\n",
0815 dm_info->cck_ok_cnt, dm_info->cck_err_cnt);
0816 seq_printf(m, " * OFDM cnt (ok, err) = (%u, %u)\n",
0817 dm_info->ofdm_ok_cnt, dm_info->ofdm_err_cnt);
0818 seq_printf(m, " * HT cnt (ok, err) = (%u, %u)\n",
0819 dm_info->ht_ok_cnt, dm_info->ht_err_cnt);
0820 seq_printf(m, " * VHT cnt (ok, err) = (%u, %u)\n",
0821 dm_info->vht_ok_cnt, dm_info->vht_err_cnt);
0822
0823 return 0;
0824 }
0825
0826 static int rtw_debugfs_get_coex_info(struct seq_file *m, void *v)
0827 {
0828 struct rtw_debugfs_priv *debugfs_priv = m->private;
0829 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0830
0831 rtw_coex_display_coex_info(rtwdev, m);
0832
0833 return 0;
0834 }
0835
0836 static ssize_t rtw_debugfs_set_coex_enable(struct file *filp,
0837 const char __user *buffer,
0838 size_t count, loff_t *loff)
0839 {
0840 struct seq_file *seqpriv = (struct seq_file *)filp->private_data;
0841 struct rtw_debugfs_priv *debugfs_priv = seqpriv->private;
0842 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0843 struct rtw_coex *coex = &rtwdev->coex;
0844 char tmp[32 + 1];
0845 bool enable;
0846 int ret;
0847
0848 rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 1);
0849
0850 ret = kstrtobool(tmp, &enable);
0851 if (ret) {
0852 rtw_warn(rtwdev, "invalid arguments\n");
0853 return ret;
0854 }
0855
0856 mutex_lock(&rtwdev->mutex);
0857 coex->manual_control = !enable;
0858 mutex_unlock(&rtwdev->mutex);
0859
0860 return count;
0861 }
0862
0863 static int rtw_debugfs_get_coex_enable(struct seq_file *m, void *v)
0864 {
0865 struct rtw_debugfs_priv *debugfs_priv = m->private;
0866 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0867 struct rtw_coex *coex = &rtwdev->coex;
0868
0869 seq_printf(m, "coex mechanism %s\n",
0870 coex->manual_control ? "disabled" : "enabled");
0871
0872 return 0;
0873 }
0874
0875 static ssize_t rtw_debugfs_set_edcca_enable(struct file *filp,
0876 const char __user *buffer,
0877 size_t count, loff_t *loff)
0878 {
0879 struct seq_file *seqpriv = (struct seq_file *)filp->private_data;
0880 struct rtw_debugfs_priv *debugfs_priv = seqpriv->private;
0881 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0882 bool input;
0883 int err;
0884
0885 err = kstrtobool_from_user(buffer, count, &input);
0886 if (err)
0887 return err;
0888
0889 rtw_edcca_enabled = input;
0890 rtw_phy_adaptivity_set_mode(rtwdev);
0891
0892 return count;
0893 }
0894
0895 static int rtw_debugfs_get_edcca_enable(struct seq_file *m, void *v)
0896 {
0897 struct rtw_debugfs_priv *debugfs_priv = m->private;
0898 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0899 struct rtw_dm_info *dm_info = &rtwdev->dm_info;
0900
0901 seq_printf(m, "EDCCA %s: EDCCA mode %d\n",
0902 rtw_edcca_enabled ? "enabled" : "disabled",
0903 dm_info->edcca_mode);
0904 return 0;
0905 }
0906
0907 static ssize_t rtw_debugfs_set_fw_crash(struct file *filp,
0908 const char __user *buffer,
0909 size_t count, loff_t *loff)
0910 {
0911 struct seq_file *seqpriv = (struct seq_file *)filp->private_data;
0912 struct rtw_debugfs_priv *debugfs_priv = seqpriv->private;
0913 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0914 char tmp[32 + 1];
0915 bool input;
0916 int ret;
0917
0918 rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 1);
0919
0920 ret = kstrtobool(tmp, &input);
0921 if (ret)
0922 return -EINVAL;
0923
0924 if (!input)
0925 return -EINVAL;
0926
0927 if (test_bit(RTW_FLAG_RESTARTING, rtwdev->flags))
0928 return -EINPROGRESS;
0929
0930 mutex_lock(&rtwdev->mutex);
0931 rtw_leave_lps_deep(rtwdev);
0932 set_bit(RTW_FLAG_RESTART_TRIGGERING, rtwdev->flags);
0933 rtw_write8(rtwdev, REG_HRCV_MSG, 1);
0934 mutex_unlock(&rtwdev->mutex);
0935
0936 return count;
0937 }
0938
0939 static int rtw_debugfs_get_fw_crash(struct seq_file *m, void *v)
0940 {
0941 struct rtw_debugfs_priv *debugfs_priv = m->private;
0942 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0943
0944 seq_printf(m, "%d\n",
0945 test_bit(RTW_FLAG_RESTART_TRIGGERING, rtwdev->flags) ||
0946 test_bit(RTW_FLAG_RESTARTING, rtwdev->flags));
0947 return 0;
0948 }
0949
0950 static ssize_t rtw_debugfs_set_force_lowest_basic_rate(struct file *filp,
0951 const char __user *buffer,
0952 size_t count, loff_t *loff)
0953 {
0954 struct seq_file *seqpriv = (struct seq_file *)filp->private_data;
0955 struct rtw_debugfs_priv *debugfs_priv = seqpriv->private;
0956 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0957 bool input;
0958 int err;
0959
0960 err = kstrtobool_from_user(buffer, count, &input);
0961 if (err)
0962 return err;
0963
0964 if (input)
0965 set_bit(RTW_FLAG_FORCE_LOWEST_RATE, rtwdev->flags);
0966 else
0967 clear_bit(RTW_FLAG_FORCE_LOWEST_RATE, rtwdev->flags);
0968
0969 return count;
0970 }
0971
0972 static int rtw_debugfs_get_force_lowest_basic_rate(struct seq_file *m, void *v)
0973 {
0974 struct rtw_debugfs_priv *debugfs_priv = m->private;
0975 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0976
0977 seq_printf(m, "force lowest basic rate: %d\n",
0978 test_bit(RTW_FLAG_FORCE_LOWEST_RATE, rtwdev->flags));
0979
0980 return 0;
0981 }
0982
0983 static ssize_t rtw_debugfs_set_dm_cap(struct file *filp,
0984 const char __user *buffer,
0985 size_t count, loff_t *loff)
0986 {
0987 struct seq_file *seqpriv = (struct seq_file *)filp->private_data;
0988 struct rtw_debugfs_priv *debugfs_priv = seqpriv->private;
0989 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
0990 struct rtw_dm_info *dm_info = &rtwdev->dm_info;
0991 int bit;
0992 bool en;
0993
0994 if (kstrtoint_from_user(buffer, count, 10, &bit))
0995 return -EINVAL;
0996
0997 en = bit > 0;
0998 bit = abs(bit);
0999
1000 if (bit >= RTW_DM_CAP_NUM) {
1001 rtw_warn(rtwdev, "unknown DM CAP %d\n", bit);
1002 return -EINVAL;
1003 }
1004
1005 if (en)
1006 dm_info->dm_flags &= ~BIT(bit);
1007 else
1008 dm_info->dm_flags |= BIT(bit);
1009
1010 debugfs_priv->dm_cap.bit = bit;
1011
1012 return count;
1013 }
1014
1015 static void dump_gapk_status(struct rtw_dev *rtwdev, struct seq_file *m)
1016 {
1017 struct rtw_dm_info *dm_info = &rtwdev->dm_info;
1018 struct rtw_gapk_info *txgapk = &rtwdev->dm_info.gapk;
1019 int i, path;
1020 u32 val;
1021
1022 seq_printf(m, "\n(%2d) %c%s\n\n", RTW_DM_CAP_TXGAPK,
1023 dm_info->dm_flags & BIT(RTW_DM_CAP_TXGAPK) ? '-' : '+',
1024 rtw_dm_cap_strs[RTW_DM_CAP_TXGAPK]);
1025
1026 for (path = 0; path < rtwdev->hal.rf_path_num; path++) {
1027 val = rtw_read_rf(rtwdev, path, RF_GAINTX, RFREG_MASK);
1028 seq_printf(m, "path %d:\n0x%x = 0x%x\n", path, RF_GAINTX, val);
1029
1030 for (i = 0; i < RF_HW_OFFSET_NUM; i++)
1031 seq_printf(m, "[TXGAPK] offset %d %d\n",
1032 txgapk->rf3f_fs[path][i], i);
1033 seq_puts(m, "\n");
1034 }
1035 }
1036
1037 static int rtw_debugfs_get_dm_cap(struct seq_file *m, void *v)
1038 {
1039 struct rtw_debugfs_priv *debugfs_priv = m->private;
1040 struct rtw_dev *rtwdev = debugfs_priv->rtwdev;
1041 struct rtw_dm_info *dm_info = &rtwdev->dm_info;
1042 int i;
1043
1044 switch (debugfs_priv->dm_cap.bit) {
1045 case RTW_DM_CAP_TXGAPK:
1046 dump_gapk_status(rtwdev, m);
1047 break;
1048 default:
1049 for (i = 1; i < RTW_DM_CAP_NUM; i++) {
1050 seq_printf(m, "(%2d) %c%s\n", i,
1051 dm_info->dm_flags & BIT(i) ? '-' : '+',
1052 rtw_dm_cap_strs[i]);
1053 }
1054 break;
1055 }
1056 debugfs_priv->dm_cap.bit = RTW_DM_CAP_NA;
1057 return 0;
1058 }
1059
1060 #define rtw_debug_impl_mac(page, addr) \
1061 static struct rtw_debugfs_priv rtw_debug_priv_mac_ ##page = { \
1062 .cb_read = rtw_debug_get_mac_page, \
1063 .cb_data = addr, \
1064 }
1065
1066 rtw_debug_impl_mac(0, 0x0000);
1067 rtw_debug_impl_mac(1, 0x0100);
1068 rtw_debug_impl_mac(2, 0x0200);
1069 rtw_debug_impl_mac(3, 0x0300);
1070 rtw_debug_impl_mac(4, 0x0400);
1071 rtw_debug_impl_mac(5, 0x0500);
1072 rtw_debug_impl_mac(6, 0x0600);
1073 rtw_debug_impl_mac(7, 0x0700);
1074 rtw_debug_impl_mac(10, 0x1000);
1075 rtw_debug_impl_mac(11, 0x1100);
1076 rtw_debug_impl_mac(12, 0x1200);
1077 rtw_debug_impl_mac(13, 0x1300);
1078 rtw_debug_impl_mac(14, 0x1400);
1079 rtw_debug_impl_mac(15, 0x1500);
1080 rtw_debug_impl_mac(16, 0x1600);
1081 rtw_debug_impl_mac(17, 0x1700);
1082
1083 #define rtw_debug_impl_bb(page, addr) \
1084 static struct rtw_debugfs_priv rtw_debug_priv_bb_ ##page = { \
1085 .cb_read = rtw_debug_get_bb_page, \
1086 .cb_data = addr, \
1087 }
1088
1089 rtw_debug_impl_bb(8, 0x0800);
1090 rtw_debug_impl_bb(9, 0x0900);
1091 rtw_debug_impl_bb(a, 0x0a00);
1092 rtw_debug_impl_bb(b, 0x0b00);
1093 rtw_debug_impl_bb(c, 0x0c00);
1094 rtw_debug_impl_bb(d, 0x0d00);
1095 rtw_debug_impl_bb(e, 0x0e00);
1096 rtw_debug_impl_bb(f, 0x0f00);
1097 rtw_debug_impl_bb(18, 0x1800);
1098 rtw_debug_impl_bb(19, 0x1900);
1099 rtw_debug_impl_bb(1a, 0x1a00);
1100 rtw_debug_impl_bb(1b, 0x1b00);
1101 rtw_debug_impl_bb(1c, 0x1c00);
1102 rtw_debug_impl_bb(1d, 0x1d00);
1103 rtw_debug_impl_bb(1e, 0x1e00);
1104 rtw_debug_impl_bb(1f, 0x1f00);
1105 rtw_debug_impl_bb(2c, 0x2c00);
1106 rtw_debug_impl_bb(2d, 0x2d00);
1107 rtw_debug_impl_bb(40, 0x4000);
1108 rtw_debug_impl_bb(41, 0x4100);
1109
1110 static struct rtw_debugfs_priv rtw_debug_priv_rf_dump = {
1111 .cb_read = rtw_debug_get_rf_dump,
1112 };
1113
1114 static struct rtw_debugfs_priv rtw_debug_priv_tx_pwr_tbl = {
1115 .cb_read = rtw_debugfs_get_tx_pwr_tbl,
1116 };
1117
1118 static struct rtw_debugfs_priv rtw_debug_priv_write_reg = {
1119 .cb_write = rtw_debugfs_set_write_reg,
1120 };
1121
1122 static struct rtw_debugfs_priv rtw_debug_priv_h2c = {
1123 .cb_write = rtw_debugfs_set_h2c,
1124 };
1125
1126 static struct rtw_debugfs_priv rtw_debug_priv_rf_write = {
1127 .cb_write = rtw_debugfs_set_rf_write,
1128 };
1129
1130 static struct rtw_debugfs_priv rtw_debug_priv_rf_read = {
1131 .cb_write = rtw_debugfs_set_rf_read,
1132 .cb_read = rtw_debugfs_get_rf_read,
1133 };
1134
1135 static struct rtw_debugfs_priv rtw_debug_priv_read_reg = {
1136 .cb_write = rtw_debugfs_set_read_reg,
1137 .cb_read = rtw_debugfs_get_read_reg,
1138 };
1139
1140 static struct rtw_debugfs_priv rtw_debug_priv_fix_rate = {
1141 .cb_write = rtw_debugfs_set_fix_rate,
1142 .cb_read = rtw_debugfs_get_fix_rate,
1143 };
1144
1145 static struct rtw_debugfs_priv rtw_debug_priv_dump_cam = {
1146 .cb_write = rtw_debugfs_set_single_input,
1147 .cb_read = rtw_debugfs_get_dump_cam,
1148 };
1149
1150 static struct rtw_debugfs_priv rtw_debug_priv_rsvd_page = {
1151 .cb_write = rtw_debugfs_set_rsvd_page,
1152 .cb_read = rtw_debugfs_get_rsvd_page,
1153 };
1154
1155 static struct rtw_debugfs_priv rtw_debug_priv_phy_info = {
1156 .cb_read = rtw_debugfs_get_phy_info,
1157 };
1158
1159 static struct rtw_debugfs_priv rtw_debug_priv_coex_enable = {
1160 .cb_write = rtw_debugfs_set_coex_enable,
1161 .cb_read = rtw_debugfs_get_coex_enable,
1162 };
1163
1164 static struct rtw_debugfs_priv rtw_debug_priv_coex_info = {
1165 .cb_read = rtw_debugfs_get_coex_info,
1166 };
1167
1168 static struct rtw_debugfs_priv rtw_debug_priv_edcca_enable = {
1169 .cb_write = rtw_debugfs_set_edcca_enable,
1170 .cb_read = rtw_debugfs_get_edcca_enable,
1171 };
1172
1173 static struct rtw_debugfs_priv rtw_debug_priv_fw_crash = {
1174 .cb_write = rtw_debugfs_set_fw_crash,
1175 .cb_read = rtw_debugfs_get_fw_crash,
1176 };
1177
1178 static struct rtw_debugfs_priv rtw_debug_priv_force_lowest_basic_rate = {
1179 .cb_write = rtw_debugfs_set_force_lowest_basic_rate,
1180 .cb_read = rtw_debugfs_get_force_lowest_basic_rate,
1181 };
1182
1183 static struct rtw_debugfs_priv rtw_debug_priv_dm_cap = {
1184 .cb_write = rtw_debugfs_set_dm_cap,
1185 .cb_read = rtw_debugfs_get_dm_cap,
1186 };
1187
1188 #define rtw_debugfs_add_core(name, mode, fopname, parent) \
1189 do { \
1190 rtw_debug_priv_ ##name.rtwdev = rtwdev; \
1191 if (!debugfs_create_file(#name, mode, \
1192 parent, &rtw_debug_priv_ ##name,\
1193 &file_ops_ ##fopname)) \
1194 pr_debug("Unable to initialize debugfs:%s\n", \
1195 #name); \
1196 } while (0)
1197
1198 #define rtw_debugfs_add_w(name) \
1199 rtw_debugfs_add_core(name, S_IFREG | 0222, common_write, debugfs_topdir)
1200 #define rtw_debugfs_add_rw(name) \
1201 rtw_debugfs_add_core(name, S_IFREG | 0666, single_rw, debugfs_topdir)
1202 #define rtw_debugfs_add_r(name) \
1203 rtw_debugfs_add_core(name, S_IFREG | 0444, single_r, debugfs_topdir)
1204
1205 void rtw_debugfs_init(struct rtw_dev *rtwdev)
1206 {
1207 struct dentry *debugfs_topdir;
1208
1209 debugfs_topdir = debugfs_create_dir("rtw88",
1210 rtwdev->hw->wiphy->debugfsdir);
1211 rtw_debugfs_add_w(write_reg);
1212 rtw_debugfs_add_rw(read_reg);
1213 rtw_debugfs_add_w(rf_write);
1214 rtw_debugfs_add_rw(rf_read);
1215 rtw_debugfs_add_rw(fix_rate);
1216 rtw_debugfs_add_rw(dump_cam);
1217 rtw_debugfs_add_rw(rsvd_page);
1218 rtw_debugfs_add_r(phy_info);
1219 rtw_debugfs_add_r(coex_info);
1220 rtw_debugfs_add_rw(coex_enable);
1221 rtw_debugfs_add_w(h2c);
1222 rtw_debugfs_add_r(mac_0);
1223 rtw_debugfs_add_r(mac_1);
1224 rtw_debugfs_add_r(mac_2);
1225 rtw_debugfs_add_r(mac_3);
1226 rtw_debugfs_add_r(mac_4);
1227 rtw_debugfs_add_r(mac_5);
1228 rtw_debugfs_add_r(mac_6);
1229 rtw_debugfs_add_r(mac_7);
1230 rtw_debugfs_add_r(bb_8);
1231 rtw_debugfs_add_r(bb_9);
1232 rtw_debugfs_add_r(bb_a);
1233 rtw_debugfs_add_r(bb_b);
1234 rtw_debugfs_add_r(bb_c);
1235 rtw_debugfs_add_r(bb_d);
1236 rtw_debugfs_add_r(bb_e);
1237 rtw_debugfs_add_r(bb_f);
1238 rtw_debugfs_add_r(mac_10);
1239 rtw_debugfs_add_r(mac_11);
1240 rtw_debugfs_add_r(mac_12);
1241 rtw_debugfs_add_r(mac_13);
1242 rtw_debugfs_add_r(mac_14);
1243 rtw_debugfs_add_r(mac_15);
1244 rtw_debugfs_add_r(mac_16);
1245 rtw_debugfs_add_r(mac_17);
1246 rtw_debugfs_add_r(bb_18);
1247 rtw_debugfs_add_r(bb_19);
1248 rtw_debugfs_add_r(bb_1a);
1249 rtw_debugfs_add_r(bb_1b);
1250 rtw_debugfs_add_r(bb_1c);
1251 rtw_debugfs_add_r(bb_1d);
1252 rtw_debugfs_add_r(bb_1e);
1253 rtw_debugfs_add_r(bb_1f);
1254 if (rtwdev->chip->id == RTW_CHIP_TYPE_8822C) {
1255 rtw_debugfs_add_r(bb_2c);
1256 rtw_debugfs_add_r(bb_2d);
1257 rtw_debugfs_add_r(bb_40);
1258 rtw_debugfs_add_r(bb_41);
1259 }
1260 rtw_debugfs_add_r(rf_dump);
1261 rtw_debugfs_add_r(tx_pwr_tbl);
1262 rtw_debugfs_add_rw(edcca_enable);
1263 rtw_debugfs_add_rw(fw_crash);
1264 rtw_debugfs_add_rw(force_lowest_basic_rate);
1265 rtw_debugfs_add_rw(dm_cap);
1266 }
1267
1268 #endif
1269
1270 #ifdef CONFIG_RTW88_DEBUG
1271
1272 void __rtw_dbg(struct rtw_dev *rtwdev, enum rtw_debug_mask mask,
1273 const char *fmt, ...)
1274 {
1275 struct va_format vaf = {
1276 .fmt = fmt,
1277 };
1278 va_list args;
1279
1280 va_start(args, fmt);
1281 vaf.va = &args;
1282
1283 if (rtw_debug_mask & mask)
1284 dev_printk(KERN_DEBUG, rtwdev->dev, "%pV", &vaf);
1285
1286 va_end(args);
1287 }
1288 EXPORT_SYMBOL(__rtw_dbg);
1289
1290 #endif
