silabs/wfx/debug.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Debugfs interface.
0004  *
0005  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
0006  * Copyright (c) 2010, ST-Ericsson
0007  */
0008 #include <linux/debugfs.h>
0009 #include <linux/seq_file.h>
0010 #include <linux/crc32.h>
0011
0012 #include "debug.h"
0013 #include "wfx.h"
0014 #include "sta.h"
0015 #include "main.h"
0016 #include "hif_tx.h"
0017 #include "hif_tx_mib.h"
0018
0019 #define CREATE_TRACE_POINTS
0020 #include "traces.h"
0021
0022 static const struct trace_print_flags hif_msg_print_map[] = {
0023     hif_msg_list,
0024 };
0025
0026 static const struct trace_print_flags hif_mib_print_map[] = {
0027     hif_mib_list,
0028 };
0029
0030 static const struct trace_print_flags wfx_reg_print_map[] = {
0031     wfx_reg_list,
0032 };
0033
0034 static const char *get_symbol(unsigned long val, const struct trace_print_flags *symbol_array)
0035 {
0036     int i;
0037
0038     for (i = 0; symbol_array[i].mask != -1; i++) {
0039         if (val == symbol_array[i].mask)
0040             return symbol_array[i].name;
0041     }
0042
0043     return "unknown";
0044 }
0045
0046 const char *wfx_get_hif_name(unsigned long id)
0047 {
0048     return get_symbol(id, hif_msg_print_map);
0049 }
0050
0051 const char *wfx_get_mib_name(unsigned long id)
0052 {
0053     return get_symbol(id, hif_mib_print_map);
0054 }
0055
0056 const char *wfx_get_reg_name(unsigned long id)
0057 {
0058     return get_symbol(id, wfx_reg_print_map);
0059 }
0060
0061 static int wfx_counters_show(struct seq_file *seq, void *v)
0062 {
0063     int ret, i;
0064     struct wfx_dev *wdev = seq->private;
0065     struct wfx_hif_mib_extended_count_table counters[3];
0066
0067     for (i = 0; i < ARRAY_SIZE(counters); i++) {
0068         ret = wfx_hif_get_counters_table(wdev, i, counters + i);
0069         if (ret < 0)
0070             return ret;
0071         if (ret > 0)
0072             return -EIO;
0073     }
0074
0075     seq_printf(seq, "%-24s %12s %12s %12s\n", "", "global", "iface 0", "iface 1");
0076
0077 #define PUT_COUNTER(name) \
0078     seq_printf(seq, "%-24s %12d %12d %12d\n", #name,  \
0079            le32_to_cpu(counters[2].count_##name), \
0080            le32_to_cpu(counters[0].count_##name), \
0081            le32_to_cpu(counters[1].count_##name))
0082
0083     PUT_COUNTER(tx_frames);
0084     PUT_COUNTER(tx_frames_multicast);
0085     PUT_COUNTER(tx_frames_success);
0086     PUT_COUNTER(tx_frames_retried);
0087     PUT_COUNTER(tx_frames_multi_retried);
0088     PUT_COUNTER(tx_frames_failed);
0089
0090     PUT_COUNTER(ack_failed);
0091     PUT_COUNTER(rts_success);
0092     PUT_COUNTER(rts_failed);
0093
0094     PUT_COUNTER(rx_frames);
0095     PUT_COUNTER(rx_frames_multicast);
0096     PUT_COUNTER(rx_frames_success);
0097     PUT_COUNTER(rx_frames_failed);
0098     PUT_COUNTER(drop_plcp);
0099     PUT_COUNTER(drop_fcs);
0100     PUT_COUNTER(drop_no_key);
0101     PUT_COUNTER(drop_decryption);
0102     PUT_COUNTER(drop_tkip_mic);
0103     PUT_COUNTER(drop_bip_mic);
0104     PUT_COUNTER(drop_cmac_icv);
0105     PUT_COUNTER(drop_cmac_replay);
0106     PUT_COUNTER(drop_ccmp_replay);
0107     PUT_COUNTER(drop_duplicate);
0108
0109     PUT_COUNTER(rx_bcn_miss);
0110     PUT_COUNTER(rx_bcn_success);
0111     PUT_COUNTER(rx_bcn_dtim);
0112     PUT_COUNTER(rx_bcn_dtim_aid0_clr);
0113     PUT_COUNTER(rx_bcn_dtim_aid0_set);
0114
0115 #undef PUT_COUNTER
0116
0117     for (i = 0; i < ARRAY_SIZE(counters[0].reserved); i++)
0118         seq_printf(seq, "reserved[%02d]%12s %12d %12d %12d\n", i, "",
0119                le32_to_cpu(counters[2].reserved[i]),
0120                le32_to_cpu(counters[0].reserved[i]),
0121                le32_to_cpu(counters[1].reserved[i]));
0122
0123     return 0;
0124 }
0125 DEFINE_SHOW_ATTRIBUTE(wfx_counters);
0126
0127 static const char * const channel_names[] = {
0128     [0] = "1M",
0129     [1] = "2M",
0130     [2] = "5.5M",
0131     [3] = "11M",
0132     /* Entries 4 and 5 does not exist */
0133     [6] = "6M",
0134     [7] = "9M",
0135     [8] = "12M",
0136     [9] = "18M",
0137     [10] = "24M",
0138     [11] = "36M",
0139     [12] = "48M",
0140     [13] = "54M",
0141     [14] = "MCS0",
0142     [15] = "MCS1",
0143     [16] = "MCS2",
0144     [17] = "MCS3",
0145     [18] = "MCS4",
0146     [19] = "MCS5",
0147     [20] = "MCS6",
0148     [21] = "MCS7",
0149 };
0150
0151 static int wfx_rx_stats_show(struct seq_file *seq, void *v)
0152 {
0153     struct wfx_dev *wdev = seq->private;
0154     struct wfx_hif_rx_stats *st = &wdev->rx_stats;
0155     int i;
0156
0157     mutex_lock(&wdev->rx_stats_lock);
0158     seq_printf(seq, "Timestamp: %dus\n", st->date);
0159     seq_printf(seq, "Low power clock: frequency %uHz, external %s\n",
0160            le32_to_cpu(st->pwr_clk_freq), st->is_ext_pwr_clk ? "yes" : "no");
0161     seq_printf(seq, "Num. of frames: %d, PER (x10e4): %d, Throughput: %dKbps/s\n",
0162            st->nb_rx_frame, st->per_total, st->throughput);
0163     seq_puts(seq, "       Num. of      PER     RSSI      SNR      CFO\n");
0164     seq_puts(seq, "        frames  (x10e4)    (dBm)     (dB)    (kHz)\n");
0165     for (i = 0; i < ARRAY_SIZE(channel_names); i++) {
0166         if (channel_names[i])
0167             seq_printf(seq, "%5s %8d %8d %8d %8d %8d\n",
0168                    channel_names[i],
0169                    le32_to_cpu(st->nb_rx_by_rate[i]),
0170                    le16_to_cpu(st->per[i]),
0171                    (s16)le16_to_cpu(st->rssi[i]) / 100,
0172                    (s16)le16_to_cpu(st->snr[i]) / 100,
0173                    (s16)le16_to_cpu(st->cfo[i]));
0174     }
0175     mutex_unlock(&wdev->rx_stats_lock);
0176
0177     return 0;
0178 }
0179 DEFINE_SHOW_ATTRIBUTE(wfx_rx_stats);
0180
0181 static int wfx_tx_power_loop_show(struct seq_file *seq, void *v)
0182 {
0183     struct wfx_dev *wdev = seq->private;
0184     struct wfx_hif_tx_power_loop_info *st = &wdev->tx_power_loop_info;
0185     int tmp;
0186
0187     mutex_lock(&wdev->tx_power_loop_info_lock);
0188     tmp = le16_to_cpu(st->tx_gain_dig);
0189     seq_printf(seq, "Tx gain digital: %d\n", tmp);
0190     tmp = le16_to_cpu(st->tx_gain_pa);
0191     seq_printf(seq, "Tx gain PA: %d\n", tmp);
0192     tmp = (s16)le16_to_cpu(st->target_pout);
0193     seq_printf(seq, "Target Pout: %d.%02d dBm\n", tmp / 4, (tmp % 4) * 25);
0194     tmp = (s16)le16_to_cpu(st->p_estimation);
0195     seq_printf(seq, "FEM Pout: %d.%02d dBm\n", tmp / 4, (tmp % 4) * 25);
0196     tmp = le16_to_cpu(st->vpdet);
0197     seq_printf(seq, "Vpdet: %d mV\n", tmp);
0198     seq_printf(seq, "Measure index: %d\n", st->measurement_index);
0199     mutex_unlock(&wdev->tx_power_loop_info_lock);
0200
0201     return 0;
0202 }
0203 DEFINE_SHOW_ATTRIBUTE(wfx_tx_power_loop);
0204
0205 static ssize_t wfx_send_pds_write(struct file *file, const char __user *user_buf,
0206                   size_t count, loff_t *ppos)
0207 {
0208     struct wfx_dev *wdev = file->private_data;
0209     char *buf;
0210     int ret;
0211
0212     if (*ppos != 0) {
0213         dev_dbg(wdev->dev, "PDS data must be written in one transaction");
0214         return -EBUSY;
0215     }
0216     buf = memdup_user(user_buf, count);
0217     if (IS_ERR(buf))
0218         return PTR_ERR(buf);
0219     *ppos = *ppos + count;
0220     ret = wfx_send_pds(wdev, buf, count);
0221     kfree(buf);
0222     if (ret < 0)
0223         return ret;
0224     return count;
0225 }
0226
0227 static const struct file_operations wfx_send_pds_fops = {
0228     .open = simple_open,
0229     .write = wfx_send_pds_write,
0230 };
0231
0232 struct dbgfs_hif_msg {
0233     struct wfx_dev *wdev;
0234     struct completion complete;
0235     u8 reply[1024];
0236     int ret;
0237 };
0238
0239 static ssize_t wfx_send_hif_msg_write(struct file *file, const char __user *user_buf,
0240                       size_t count, loff_t *ppos)
0241 {
0242     struct dbgfs_hif_msg *context = file->private_data;
0243     struct wfx_dev *wdev = context->wdev;
0244     struct wfx_hif_msg *request;
0245
0246     if (completion_done(&context->complete)) {
0247         dev_dbg(wdev->dev, "read previous result before start a new one\n");
0248         return -EBUSY;
0249     }
0250     if (count < sizeof(struct wfx_hif_msg))
0251         return -EINVAL;
0252
0253     /* wfx_cmd_send() checks that reply buffer is wide enough, but does not return precise
0254      * length read. User have to know how many bytes should be read. Filling reply buffer with a
0255      * memory pattern may help user.
0256      */
0257     memset(context->reply, 0xFF, sizeof(context->reply));
0258     request = memdup_user(user_buf, count);
0259     if (IS_ERR(request))
0260         return PTR_ERR(request);
0261     if (le16_to_cpu(request->len) != count) {
0262         kfree(request);
0263         return -EINVAL;
0264     }
0265     context->ret = wfx_cmd_send(wdev, request, context->reply, sizeof(context->reply), false);
0266
0267     kfree(request);
0268     complete(&context->complete);
0269     return count;
0270 }
0271
0272 static ssize_t wfx_send_hif_msg_read(struct file *file, char __user *user_buf,
0273                      size_t count, loff_t *ppos)
0274 {
0275     struct dbgfs_hif_msg *context = file->private_data;
0276     int ret;
0277
0278     if (count > sizeof(context->reply))
0279         return -EINVAL;
0280     ret = wait_for_completion_interruptible(&context->complete);
0281     if (ret)
0282         return ret;
0283     if (context->ret < 0)
0284         return context->ret;
0285     /* Be careful, write() is waiting for a full message while read() only returns a payload */
0286     if (copy_to_user(user_buf, context->reply, count))
0287         return -EFAULT;
0288
0289     return count;
0290 }
0291
0292 static int wfx_send_hif_msg_open(struct inode *inode, struct file *file)
0293 {
0294     struct dbgfs_hif_msg *context = kzalloc(sizeof(*context), GFP_KERNEL);
0295
0296     if (!context)
0297         return -ENOMEM;
0298     context->wdev = inode->i_private;
0299     init_completion(&context->complete);
0300     file->private_data = context;
0301     return 0;
0302 }
0303
0304 static int wfx_send_hif_msg_release(struct inode *inode, struct file *file)
0305 {
0306     struct dbgfs_hif_msg *context = file->private_data;
0307
0308     kfree(context);
0309     return 0;
0310 }
0311
0312 static const struct file_operations wfx_send_hif_msg_fops = {
0313     .open = wfx_send_hif_msg_open,
0314     .release = wfx_send_hif_msg_release,
0315     .write = wfx_send_hif_msg_write,
0316     .read = wfx_send_hif_msg_read,
0317 };
0318
0319 int wfx_debug_init(struct wfx_dev *wdev)
0320 {
0321     struct dentry *d;
0322
0323     d = debugfs_create_dir("wfx", wdev->hw->wiphy->debugfsdir);
0324     debugfs_create_file("counters", 0444, d, wdev, &wfx_counters_fops);
0325     debugfs_create_file("rx_stats", 0444, d, wdev, &wfx_rx_stats_fops);
0326     debugfs_create_file("tx_power_loop", 0444, d, wdev, &wfx_tx_power_loop_fops);
0327     debugfs_create_file("send_pds", 0200, d, wdev, &wfx_send_pds_fops);
0328     debugfs_create_file("send_hif_msg", 0600, d, wdev, &wfx_send_hif_msg_fops);
0329
0330     return 0;
0331 }