root/drivers/net/wireless/rsi/rsi_91x_debugfs.c

DEFINITIONS

1. rsi_sdio_stats_read
2. rsi_sdio_stats_open
3. rsi_version_read
4. rsi_version_open
5. rsi_stats_read
6. rsi_stats_open
7. rsi_debug_zone_read
8. rsi_debug_read
9. rsi_debug_zone_write
10. rsi_init_dbgfs
11. rsi_remove_dbgfs

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