drivers/net/wireless/rsi/rsi_91x_debugfs.c

   1 /**
   2  * Copyright (c) 2014 Redpine Signals Inc.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "rsi_debugfs.h"
  18 #include "rsi_sdio.h"
  19
  20 /**
  21  * rsi_sdio_stats_read() - This function returns the sdio status of the driver.
  22  * @seq: Pointer to the sequence file structure.
  23  * @data: Pointer to the data.
  24  *
  25  * Return: 0 on success, -1 on failure.
  26  */
  27 static int rsi_sdio_stats_read(struct seq_file *seq, void *data)
  28 {
  29         struct rsi_common *common = seq->private;
  30         struct rsi_hw *adapter = common->priv;
  31         struct rsi_91x_sdiodev *dev =
  32                 (struct rsi_91x_sdiodev *)adapter->rsi_dev;
  33
  34         seq_printf(seq, "total_sdio_interrupts: %d\n",
  35                    dev->rx_info.sdio_int_counter);
  36         seq_printf(seq, "sdio_msdu_pending_intr_count: %d\n",
  37                    dev->rx_info.total_sdio_msdu_pending_intr);
  38         seq_printf(seq, "sdio_buff_full_count : %d\n",
  39                    dev->rx_info.buf_full_counter);
  40         seq_printf(seq, "sdio_buf_semi_full_count %d\n",
  41                    dev->rx_info.buf_semi_full_counter);
  42         seq_printf(seq, "sdio_unknown_intr_count: %d\n",
  43                    dev->rx_info.total_sdio_unknown_intr);
  44         /* RX Path Stats */
  45         seq_printf(seq, "BUFFER FULL STATUS  : %d\n",
  46                    dev->rx_info.buffer_full);
  47         seq_printf(seq, "SEMI BUFFER FULL STATUS  : %d\n",
  48                    dev->rx_info.semi_buffer_full);
  49         seq_printf(seq, "MGMT BUFFER FULL STATUS  : %d\n",
  50                    dev->rx_info.mgmt_buffer_full);
  51         seq_printf(seq, "BUFFER FULL COUNTER  : %d\n",
  52                    dev->rx_info.buf_full_counter);
  53         seq_printf(seq, "BUFFER SEMI FULL COUNTER  : %d\n",
  54                    dev->rx_info.buf_semi_full_counter);
  55         seq_printf(seq, "MGMT BUFFER FULL COUNTER  : %d\n",
  56                    dev->rx_info.mgmt_buf_full_counter);
  57
  58         return 0;
  59 }
  60
  61 /**
  62  * rsi_sdio_stats_open() - This funtion calls single open function of seq_file
  63  *                         to open file and read contents from it.
  64  * @inode: Pointer to the inode structure.
  65  * @file: Pointer to the file structure.
  66  *
  67  * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
  68  */
  69 static int rsi_sdio_stats_open(struct inode *inode,
  70                                struct file *file)
  71 {
  72         return single_open(file, rsi_sdio_stats_read, inode->i_private);
  73 }
  74
  75 /**
  76  * rsi_version_read() - This function gives driver and firmware version number.
  77  * @seq: Pointer to the sequence file structure.
  78  * @data: Pointer to the data.
  79  *
  80  * Return: 0 on success, -1 on failure.
  81  */
  82 static int rsi_version_read(struct seq_file *seq, void *data)
  83 {
  84         struct rsi_common *common = seq->private;
  85
  86         common->driver_ver.major = 0;
  87         common->driver_ver.minor = 1;
  88         common->driver_ver.release_num = 0;
  89         common->driver_ver.patch_num = 0;
  90         seq_printf(seq, "Driver : %x.%d.%d.%d\nLMAC   : %d.%d.%d.%d\n",
  91                    common->driver_ver.major,
  92                    common->driver_ver.minor,
  93                    common->driver_ver.release_num,
  94                    common->driver_ver.patch_num,
  95                    common->fw_ver.major,
  96                    common->fw_ver.minor,
  97                    common->fw_ver.release_num,
  98                    common->fw_ver.patch_num);
  99         return 0;
 100 }
 101
 102 /**
 103  * rsi_version_open() - This funtion calls single open function of seq_file to
 104  *                      open file and read contents from it.
 105  * @inode: Pointer to the inode structure.
 106  * @file: Pointer to the file structure.
 107  *
 108  * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
 109  */
 110 static int rsi_version_open(struct inode *inode,
 111                                  struct file *file)
 112 {
 113         return single_open(file, rsi_version_read, inode->i_private);
 114 }
 115
 116 /**
 117  * rsi_stats_read() - This function return the status of the driver.
 118  * @seq: Pointer to the sequence file structure.
 119  * @data: Pointer to the data.
 120  *
 121  * Return: 0 on success, -1 on failure.
 122  */
 123 static int rsi_stats_read(struct seq_file *seq, void *data)
 124 {
 125         struct rsi_common *common = seq->private;
 126
 127         unsigned char fsm_state[][32] = {
 128                 "FSM_FW_NOT_LOADED",
 129                 "FSM_CARD_NOT_READY",
 130                 "FSM_COMMON_DEV_PARAMS_SENT",
 131                 "FSM_BOOT_PARAMS_SENT",
 132                 "FSM_EEPROM_READ_MAC_ADDR",
 133                 "FSM_EEPROM_READ_RF_TYPE",
 134                 "FSM_RESET_MAC_SENT",
 135                 "FSM_RADIO_CAPS_SENT",
 136                 "FSM_BB_RF_PROG_SENT",
 137                 "FSM_MAC_INIT_DONE"
 138         };
 139         seq_puts(seq, "==> RSI STA DRIVER STATUS <==\n");
 140         seq_puts(seq, "DRIVER_FSM_STATE: ");
 141
 142         BUILD_BUG_ON(ARRAY_SIZE(fsm_state) != NUM_FSM_STATES);
 143
 144         if (common->fsm_state <= FSM_MAC_INIT_DONE)
 145                 seq_printf(seq, "%s", fsm_state[common->fsm_state]);
 146
 147         seq_printf(seq, "(%d)\n\n", common->fsm_state);
 148
 149         /* Mgmt TX Path Stats */
 150         seq_printf(seq, "total_mgmt_pkt_send : %d\n",
 151                    common->tx_stats.total_tx_pkt_send[MGMT_SOFT_Q]);
 152         seq_printf(seq, "total_mgmt_pkt_queued : %d\n",
 153                    skb_queue_len(&common->tx_queue[MGMT_SOFT_Q]));
 154         seq_printf(seq, "total_mgmt_pkt_freed  : %d\n",
 155                    common->tx_stats.total_tx_pkt_freed[MGMT_SOFT_Q]);
 156
 157         /* Data TX Path Stats */
 158         seq_printf(seq, "total_data_vo_pkt_send: %8d\t",
 159                    common->tx_stats.total_tx_pkt_send[VO_Q]);
 160         seq_printf(seq, "total_data_vo_pkt_queued:  %8d\t",
 161                    skb_queue_len(&common->tx_queue[VO_Q]));
 162         seq_printf(seq, "total_vo_pkt_freed: %8d\n",
 163                    common->tx_stats.total_tx_pkt_freed[VO_Q]);
 164         seq_printf(seq, "total_data_vi_pkt_send: %8d\t",
 165                    common->tx_stats.total_tx_pkt_send[VI_Q]);
 166         seq_printf(seq, "total_data_vi_pkt_queued:  %8d\t",
 167                    skb_queue_len(&common->tx_queue[VI_Q]));
 168         seq_printf(seq, "total_vi_pkt_freed: %8d\n",
 169                    common->tx_stats.total_tx_pkt_freed[VI_Q]);
 170         seq_printf(seq,  "total_data_be_pkt_send: %8d\t",
 171                    common->tx_stats.total_tx_pkt_send[BE_Q]);
 172         seq_printf(seq, "total_data_be_pkt_queued:  %8d\t",
 173                    skb_queue_len(&common->tx_queue[BE_Q]));
 174         seq_printf(seq, "total_be_pkt_freed: %8d\n",
 175                    common->tx_stats.total_tx_pkt_freed[BE_Q]);
 176         seq_printf(seq, "total_data_bk_pkt_send: %8d\t",
 177                    common->tx_stats.total_tx_pkt_send[BK_Q]);
 178         seq_printf(seq, "total_data_bk_pkt_queued:  %8d\t",
 179                    skb_queue_len(&common->tx_queue[BK_Q]));
 180         seq_printf(seq, "total_bk_pkt_freed: %8d\n",
 181                    common->tx_stats.total_tx_pkt_freed[BK_Q]);
 182
 183         seq_puts(seq, "\n");
 184         return 0;
 185 }
 186
 187 /**
 188  * rsi_stats_open() - This funtion calls single open function of seq_file to
 189  *                    open file and read contents from it.
 190  * @inode: Pointer to the inode structure.
 191  * @file: Pointer to the file structure.
 192  *
 193  * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
 194  */
 195 static int rsi_stats_open(struct inode *inode,
 196                           struct file *file)
 197 {
 198         return single_open(file, rsi_stats_read, inode->i_private);
 199 }
 200
 201 /**
 202  * rsi_debug_zone_read() - This function display the currently enabled debug zones.
 203  * @seq: Pointer to the sequence file structure.
 204  * @data: Pointer to the data.
 205  *
 206  * Return: 0 on success, -1 on failure.
 207  */
 208 static int rsi_debug_zone_read(struct seq_file *seq, void *data)
 209 {
 210         rsi_dbg(FSM_ZONE, "%x: rsi_enabled zone", rsi_zone_enabled);
 211         seq_printf(seq, "The zones available are %#x\n",
 212                    rsi_zone_enabled);
 213         return 0;
 214 }
 215
 216 /**
 217  * rsi_debug_read() - This funtion calls single open function of seq_file to
 218  *                    open file and read contents from it.
 219  * @inode: Pointer to the inode structure.
 220  * @file: Pointer to the file structure.
 221  *
 222  * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
 223  */
 224 static int rsi_debug_read(struct inode *inode,
 225                           struct file *file)
 226 {
 227         return single_open(file, rsi_debug_zone_read, inode->i_private);
 228 }
 229
 230 /**
 231  * rsi_debug_zone_write() - This function writes into hal queues as per user
 232  *                          requirement.
 233  * @filp: Pointer to the file structure.
 234  * @buff: Pointer to the character buffer.
 235  * @len: Length of the data to be written into buffer.
 236  * @data: Pointer to the data.
 237  *
 238  * Return: len: Number of bytes read.
 239  */
 240 static ssize_t rsi_debug_zone_write(struct file *filp,
 241                                     const char __user *buff,
 242                                     size_t len,
 243                                     loff_t *data)
 244 {
 245         unsigned long dbg_zone;
 246         int ret;
 247
 248         if (!len)
 249                 return 0;
 250
 251         ret = kstrtoul_from_user(buff, len, 16, &dbg_zone);
 252
 253         if (ret)
 254                 return ret;
 255
 256         rsi_zone_enabled = dbg_zone;
 257         return len;
 258 }
 259
 260 #define FOPS(fopen) { \
 261         .owner = THIS_MODULE, \
 262         .open = (fopen), \
 263         .read = seq_read, \
 264         .llseek = seq_lseek, \
 265 }
 266
 267 #define FOPS_RW(fopen, fwrite) { \
 268         .owner = THIS_MODULE, \
 269         .open = (fopen), \
 270         .read = seq_read, \
 271         .llseek = seq_lseek, \
 272         .write = (fwrite), \
 273 }
 274
 275 static const struct rsi_dbg_files dev_debugfs_files[] = {
 276         {"version", 0644, FOPS(rsi_version_open),},
 277         {"stats", 0644, FOPS(rsi_stats_open),},
 278         {"debug_zone", 0666, FOPS_RW(rsi_debug_read, rsi_debug_zone_write),},
 279         {"sdio_stats", 0644, FOPS(rsi_sdio_stats_open),},
 280 };
 281
 282 /**
 283  * rsi_init_dbgfs() - This function initializes the dbgfs entry.
 284  * @adapter: Pointer to the adapter structure.
 285  *
 286  * Return: 0 on success, -1 on failure.
 287  */
 288 int rsi_init_dbgfs(struct rsi_hw *adapter)
 289 {
 290         struct rsi_common *common = adapter->priv;
 291         struct rsi_debugfs *dev_dbgfs;
 292         char devdir[6];
 293         int ii;
 294         const struct rsi_dbg_files *files;
 295
 296         dev_dbgfs = kzalloc(sizeof(*dev_dbgfs), GFP_KERNEL);
 297         if (!dev_dbgfs)
 298                 return -ENOMEM;
 299
 300         adapter->dfsentry = dev_dbgfs;
 301
 302         snprintf(devdir, sizeof(devdir), "%s",
 303                  wiphy_name(adapter->hw->wiphy));
 304
 305         dev_dbgfs->subdir = debugfs_create_dir(devdir, NULL);
 306
 307         if (!dev_dbgfs->subdir) {
 308                 kfree(dev_dbgfs);
 309                 return -ENOMEM;
 310         }
 311
 312         for (ii = 0; ii < adapter->num_debugfs_entries; ii++) {
 313                 files = &dev_debugfs_files[ii];
 314                 dev_dbgfs->rsi_files[ii] =
 315                 debugfs_create_file(files->name,
 316                                     files->perms,
 317                                     dev_dbgfs->subdir,
 318                                     common,
 319                                     &files->fops);
 320         }
 321         return 0;
 322 }
 323 EXPORT_SYMBOL_GPL(rsi_init_dbgfs);
 324
 325 /**
 326  * rsi_remove_dbgfs() - Removes the previously created dbgfs file entries
 327  *                      in the reverse order of creation.
 328  * @adapter: Pointer to the adapter structure.
 329  *
 330  * Return: None.
 331  */
 332 void rsi_remove_dbgfs(struct rsi_hw *adapter)
 333 {
 334         struct rsi_debugfs *dev_dbgfs = adapter->dfsentry;
 335
 336         if (!dev_dbgfs)
 337                 return;
 338
 339         debugfs_remove_recursive(dev_dbgfs->subdir);
 340 }
 341 EXPORT_SYMBOL_GPL(rsi_remove_dbgfs);