rsi_91x_debugfs.c (9958B)
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 */ 27static 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 */ 69static 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 */ 82static 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 */ 103static 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 */ 116static int rsi_stats_read(struct seq_file *seq, void *data) 117{ 118 struct rsi_common *common = seq->private; 119 120 static const 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 */ 188static 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 */ 201static 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 */ 217static 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 */ 233static 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 268static 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 */ 281int 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} 311EXPORT_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 */ 320void 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} 329EXPORT_SYMBOL_GPL(rsi_remove_dbgfs);