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