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); 342