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_CARD_NOT_READY",
 129                 "FSM_BOOT_PARAMS_SENT",
 130                 "FSM_EEPROM_READ_MAC_ADDR",
 131                 "FSM_RESET_MAC_SENT",
 132                 "FSM_RADIO_CAPS_SENT",
 133                 "FSM_BB_RF_PROG_SENT",
 134                 "FSM_MAC_INIT_DONE"
 135         };
 136         seq_puts(seq, "==> RSI STA DRIVER STATUS <==\n");
 137         seq_puts(seq, "DRIVER_FSM_STATE: ");
 138
 139         if (common->fsm_state <= FSM_MAC_INIT_DONE)
 140                 seq_printf(seq, "%s", fsm_state[common->fsm_state]);
 141
 142         seq_printf(seq, "(%d)\n\n", common->fsm_state);
 143
 144         /* Mgmt TX Path Stats */
 145         seq_printf(seq, "total_mgmt_pkt_send : %d\n",
 146                    common->tx_stats.total_tx_pkt_send[MGMT_SOFT_Q]);
 147         seq_printf(seq, "total_mgmt_pkt_queued : %d\n",
 148                    skb_queue_len(&common->tx_queue[MGMT_SOFT_Q]));
 149         seq_printf(seq, "total_mgmt_pkt_freed  : %d\n",
 150                    common->tx_stats.total_tx_pkt_freed[MGMT_SOFT_Q]);
 151
 152         /* Data TX Path Stats */
 153         seq_printf(seq, "total_data_vo_pkt_send: %8d\t",
 154                    common->tx_stats.total_tx_pkt_send[VO_Q]);
 155         seq_printf(seq, "total_data_vo_pkt_queued:  %8d\t",
 156                    skb_queue_len(&common->tx_queue[VO_Q]));
 157         seq_printf(seq, "total_vo_pkt_freed: %8d\n",
 158                    common->tx_stats.total_tx_pkt_freed[VO_Q]);
 159         seq_printf(seq, "total_data_vi_pkt_send: %8d\t",
 160                    common->tx_stats.total_tx_pkt_send[VI_Q]);
 161         seq_printf(seq, "total_data_vi_pkt_queued:  %8d\t",
 162                    skb_queue_len(&common->tx_queue[VI_Q]));
 163         seq_printf(seq, "total_vi_pkt_freed: %8d\n",
 164                    common->tx_stats.total_tx_pkt_freed[VI_Q]);
 165         seq_printf(seq,  "total_data_be_pkt_send: %8d\t",
 166                    common->tx_stats.total_tx_pkt_send[BE_Q]);
 167         seq_printf(seq, "total_data_be_pkt_queued:  %8d\t",
 168                    skb_queue_len(&common->tx_queue[BE_Q]));
 169         seq_printf(seq, "total_be_pkt_freed: %8d\n",
 170                    common->tx_stats.total_tx_pkt_freed[BE_Q]);
 171         seq_printf(seq, "total_data_bk_pkt_send: %8d\t",
 172                    common->tx_stats.total_tx_pkt_send[BK_Q]);
 173         seq_printf(seq, "total_data_bk_pkt_queued:  %8d\t",
 174                    skb_queue_len(&common->tx_queue[BK_Q]));
 175         seq_printf(seq, "total_bk_pkt_freed: %8d\n",
 176                    common->tx_stats.total_tx_pkt_freed[BK_Q]);
 177
 178         seq_puts(seq, "\n");
 179         return 0;
 180 }
 181
 182 /**
 183  * rsi_stats_open() - This funtion calls single open function of seq_file to
 184  *                    open file and read contents from it.
 185  * @inode: Pointer to the inode structure.
 186  * @file: Pointer to the file structure.
 187  *
 188  * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
 189  */
 190 static int rsi_stats_open(struct inode *inode,
 191                           struct file *file)
 192 {
 193         return single_open(file, rsi_stats_read, inode->i_private);
 194 }
 195
 196 /**
 197  * rsi_debug_zone_read() - This function display the currently enabled debug zones.
 198  * @seq: Pointer to the sequence file structure.
 199  * @data: Pointer to the data.
 200  *
 201  * Return: 0 on success, -1 on failure.
 202  */
 203 static int rsi_debug_zone_read(struct seq_file *seq, void *data)
 204 {
 205         rsi_dbg(FSM_ZONE, "%x: rsi_enabled zone", rsi_zone_enabled);
 206         seq_printf(seq, "The zones available are %#x\n",
 207                    rsi_zone_enabled);
 208         return 0;
 209 }
 210
 211 /**
 212  * rsi_debug_read() - This funtion calls single open function of seq_file to
 213  *                    open file and read contents from it.
 214  * @inode: Pointer to the inode structure.
 215  * @file: Pointer to the file structure.
 216  *
 217  * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
 218  */
 219 static int rsi_debug_read(struct inode *inode,
 220                           struct file *file)
 221 {
 222         return single_open(file, rsi_debug_zone_read, inode->i_private);
 223 }
 224
 225 /**
 226  * rsi_debug_zone_write() - This function writes into hal queues as per user
 227  *                          requirement.
 228  * @filp: Pointer to the file structure.
 229  * @buff: Pointer to the character buffer.
 230  * @len: Length of the data to be written into buffer.
 231  * @data: Pointer to the data.
 232  *
 233  * Return: len: Number of bytes read.
 234  */
 235 static ssize_t rsi_debug_zone_write(struct file *filp,
 236                                     const char __user *buff,
 237                                     size_t len,
 238                                     loff_t *data)
 239 {
 240         unsigned long dbg_zone;
 241         int ret;
 242
 243         if (!len)
 244                 return 0;
 245
 246         ret = kstrtoul_from_user(buff, len, 16, &dbg_zone);
 247
 248         if (ret)
 249                 return ret;
 250
 251         rsi_zone_enabled = dbg_zone;
 252         return len;
 253 }
 254
 255 #define FOPS(fopen) { \
 256         .owner = THIS_MODULE, \
 257         .open = (fopen), \
 258         .read = seq_read, \
 259         .llseek = seq_lseek, \
 260 }
 261
 262 #define FOPS_RW(fopen, fwrite) { \
 263         .owner = THIS_MODULE, \
 264         .open = (fopen), \
 265         .read = seq_read, \
 266         .llseek = seq_lseek, \
 267         .write = (fwrite), \
 268 }
 269
 270 static const struct rsi_dbg_files dev_debugfs_files[] = {
 271         {"version", 0644, FOPS(rsi_version_open),},
 272         {"stats", 0644, FOPS(rsi_stats_open),},
 273         {"debug_zone", 0666, FOPS_RW(rsi_debug_read, rsi_debug_zone_write),},
 274         {"sdio_stats", 0644, FOPS(rsi_sdio_stats_open),},
 275 };
 276
 277 /**
 278  * rsi_init_dbgfs() - This function initializes the dbgfs entry.
 279  * @adapter: Pointer to the adapter structure.
 280  *
 281  * Return: 0 on success, -1 on failure.
 282  */
 283 int rsi_init_dbgfs(struct rsi_hw *adapter)
 284 {
 285         struct rsi_common *common = adapter->priv;
 286         struct rsi_debugfs *dev_dbgfs;
 287         char devdir[6];
 288         int ii;
 289         const struct rsi_dbg_files *files;
 290
 291         dev_dbgfs = kzalloc(sizeof(*dev_dbgfs), GFP_KERNEL);
 292         if (!dev_dbgfs)
 293                 return -ENOMEM;
 294
 295         adapter->dfsentry = dev_dbgfs;
 296
 297         snprintf(devdir, sizeof(devdir), "%s",
 298                  wiphy_name(adapter->hw->wiphy));
 299
 300         dev_dbgfs->subdir = debugfs_create_dir(devdir, NULL);
 301
 302         if (!dev_dbgfs->subdir) {
 303                 kfree(dev_dbgfs);
 304                 return -ENOMEM;
 305         }
 306
 307         for (ii = 0; ii < adapter->num_debugfs_entries; ii++) {
 308                 files = &dev_debugfs_files[ii];
 309                 dev_dbgfs->rsi_files[ii] =
 310                 debugfs_create_file(files->name,
 311                                     files->perms,
 312                                     dev_dbgfs->subdir,
 313                                     common,
 314                                     &files->fops);
 315         }
 316         return 0;
 317 }
 318 EXPORT_SYMBOL_GPL(rsi_init_dbgfs);
 319
 320 /**
 321  * rsi_remove_dbgfs() - Removes the previously created dbgfs file entries
 322  *                      in the reverse order of creation.
 323  * @adapter: Pointer to the adapter structure.
 324  *
 325  * Return: None.
 326  */
 327 void rsi_remove_dbgfs(struct rsi_hw *adapter)
 328 {
 329         struct rsi_debugfs *dev_dbgfs = adapter->dfsentry;
 330
 331         if (!dev_dbgfs)
 332                 return;
 333
 334         debugfs_remove_recursive(dev_dbgfs->subdir);
 335 }
 336 EXPORT_SYMBOL_GPL(rsi_remove_dbgfs);